diff --git a/.envrc b/.envrc
new file mode 100644
index 00000000000..4783a05d68a
--- /dev/null
+++ b/.envrc
@@ -0,0 +1,3 @@
+use nix
+watch_file flake.nix
+watch_file flake.lock
diff --git a/.githooks/commit-msg b/.githooks/commit-msg
new file mode 100755
index 00000000000..43d6538f1d9
--- /dev/null
+++ b/.githooks/commit-msg
@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+#
+# commit-msg hook: Validates that commit messages follow Conventional Commits
+# format required by release-please.
+#
+# Format: <type>[(scope)][!]: <description>
+#
+# Valid types: feat, fix, perf, revert, docs, chore, style, refactor, test, build, ci
+#
+# Examples:
+#   feat: add new authentication flow
+#   fix(release): correct tag separator
+#   feat!: breaking change to API
+#   chore(deps): bump dependencies
+#
+# To skip this check (e.g. merge commits), use:
+#   git commit --no-verify
+
+commit_msg_file="$1"
+commit_msg=$(head -1 "$commit_msg_file")
+
+# Allow merge commits
+if echo "$commit_msg" | grep -qE '^Merge '; then
+  exit 0
+fi
+
+# Allow revert commits
+if echo "$commit_msg" | grep -qE '^Revert "'; then
+  exit 0
+fi
+
+# Allow release-please commits
+if echo "$commit_msg" | grep -qE '^chore\(release\):'; then
+  exit 0
+fi
+
+# Conventional Commits pattern:
+# <type>[(scope)][!]: <description>
+pattern='^(feat|fix|perf|revert|docs|chore|style|refactor|test|build|ci)(\([a-zA-Z0-9._-]+\))?(!)?: .+'
+
+if ! echo "$commit_msg" | grep -qE "$pattern"; then
+  echo ""
+  echo "ERROR: Commit message does not follow Conventional Commits format."
+  echo ""
+  echo "  Your message:  $commit_msg"
+  echo ""
+  echo "  Expected format: <type>[(scope)]: <description>"
+  echo ""
+  echo "  Valid types: feat, fix, perf, revert, docs, chore, style, refactor, test, build, ci"
+  echo ""
+  echo "  Examples:"
+  echo "    feat: add new authentication flow"
+  echo "    fix(release): correct tag separator"
+  echo "    feat!: breaking change to API"
+  echo ""
+  echo "  This is required for release-please to generate changelogs correctly."
+  echo "  To skip this check: git commit --no-verify"
+  echo ""
+  exit 1
+fi
diff --git a/.github/actions/ci-setup/action.yml b/.github/actions/ci-setup/action.yml
index b5ab6e03bd4..f2197d6c433 100644
--- a/.github/actions/ci-setup/action.yml
+++ b/.github/actions/ci-setup/action.yml
@@ -6,6 +6,39 @@ runs:
   using: composite
 
   steps:
+    - uses: cargo-bins/cargo-binstall@main
+    - name: Make more disk space available on public runner
+      run: |
+        cargo binstall -y --force --version 2.2.0 rmz
+
+        echo "Available storage before:"
+        sudo df -h
+        echo
+
+        sudo mv ~/.cargo/bin/rmz /usr/local/bin/rmz
+
+        sudo rmz -f $AGENT_TOOLSDIRECTORY
+        sudo rmz -f /opt/az
+        sudo rmz -f /opt/ghc
+        sudo rmz -f /opt/google
+        sudo rmz -f /opt/microsoft
+        sudo rmz -f /opt/pipx
+        sudo rmz -f /usr/lib/mono
+        sudo rmz -f /usr/local/julia*
+        sudo rmz -f /usr/local/lib/android
+        sudo rmz -f /usr/local/share/boost
+        sudo rmz -f /usr/local/share/chromium
+        sudo rmz -f /usr/local/share/powershell
+        sudo rmz -f /usr/share/az_*
+        sudo rmz -f /usr/share/dotnet
+        sudo rmz -f /usr/share/gradle-*
+        sudo rmz -f /usr/share/swift
+
+        echo "Available storage after:"
+        sudo df -h
+        echo
+      shell: bash
+
     - name: Install dependencies
       run: sudo apt update && sudo apt install -y wabt gotestsum
       shell: bash
@@ -14,8 +47,6 @@ runs:
       uses: actions/setup-node@v5
       with:
         node-version: "24"
-        cache: yarn
-        cache-dependency-path: "**/yarn.lock"
 
     - name: Setup Go
       uses: actions/setup-go@v6
diff --git a/.github/workflows/_arbitrator.yml b/.github/workflows/_arbitrator.yml
index 27badc68536..ee3e0a1589e 100644
--- a/.github/workflows/_arbitrator.yml
+++ b/.github/workflows/_arbitrator.yml
@@ -6,7 +6,7 @@ on:
 jobs:
   arbitrator:
     name: Run Arbitrator tests
-    runs-on: arbitrator-ci
+    runs-on: ubuntu-latest
     env:
       RUST_BACKTRACE: 1
       # RUSTFLAGS: -Dwarnings          # TODO: re-enable after wasmer upgrade
diff --git a/.github/workflows/_bold-legacy.yml b/.github/workflows/_bold-legacy.yml
index d0ef4248a0c..67e6776ed0a 100644
--- a/.github/workflows/_bold-legacy.yml
+++ b/.github/workflows/_bold-legacy.yml
@@ -6,7 +6,7 @@ on:
 jobs:
   bold-legacy:
     name: Run Bold Legacy challenge tests
-    runs-on: arbitrator-ci
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v5
diff --git a/.github/workflows/_codecov.yml b/.github/workflows/_codecov.yml
index be23bec84a7..ea4cd530b7b 100644
--- a/.github/workflows/_codecov.yml
+++ b/.github/workflows/_codecov.yml
@@ -24,7 +24,7 @@ on:
 jobs:
   report_summary:
     name: Aggregate test results
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
     permissions:
       contents: read
       pull-requests: write
diff --git a/.github/workflows/_detect-changes.yml b/.github/workflows/_detect-changes.yml
index 19553a66502..6971048f445 100644
--- a/.github/workflows/_detect-changes.yml
+++ b/.github/workflows/_detect-changes.yml
@@ -14,7 +14,7 @@ on:
 jobs:
   changes:
     name: Detect file changes
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
     outputs:
       arbitrator_changed: ${{ steps.changed.outputs.arbitrator_any_changed }}
       bold_legacy_changed: ${{ steps.changed.outputs.bold_legacy_any_changed }}
@@ -26,17 +26,22 @@ jobs:
           submodules: recursive
           fetch-depth: 10            # Will cover most PRs
           persist-credentials: true  # In case changed-files requires deeper depth
-
       - name: Determine if Arbitrator or Bold Legacy changed
         id: changed
-        uses: tj-actions/changed-files@v46.0.5
-        with:
-          files_yaml: |
-            arbitrator:
-              - 'arbitrator/**'
-              - 'contracts/**'
-              - 'Makefile'
-              - '.github/workflows/_arbitrator.yml'
-            bold_legacy:
-              - 'bold/legacy/**'
-              - '.github/workflows/_bold-legacy.yml'
+        run: |
+          echo "arbitrator_any_changed=false" >> $GITHUB_OUTPUT
+          echo "bold_legacy_any_changed=false" >> $GITHUB_OUTPUT
+
+      # - name: Determine if Arbitrator or Bold Legacy changed
+      #   id: changed
+      #   uses: tj-actions/changed-files@v46.0.5
+      #   with:
+      #     files_yaml: |
+      #       arbitrator:
+      #         - 'arbitrator/**'
+      #         - 'contracts/**'
+      #         - 'Makefile'
+      #         - '.github/workflows/_arbitrator.yml'
+      #       bold_legacy:
+      #         - 'bold/legacy/**'
+      #         - '.github/workflows/_bold-legacy.yml'
diff --git a/.github/workflows/_fast.yml b/.github/workflows/_fast.yml
index 0afc4c7dd29..e23f41271f1 100644
--- a/.github/workflows/_fast.yml
+++ b/.github/workflows/_fast.yml
@@ -6,7 +6,7 @@ on:
 jobs:
   lint-and-build:
     name: Lint and Build
-    runs-on: arbitrator-ci
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v5
@@ -17,10 +17,10 @@ jobs:
         uses: ./.github/actions/ci-setup
 
       - name: Build
-        run: make -j8 build test-go-deps
+        run: make -j4 build test-go-deps
 
       - name: Build all lint dependencies
-        run: make -j8 build-node-deps
+        run: make -j build-node-deps
 
       - name: GolangCI Lint
         uses: golangci/golangci-lint-action@v9
diff --git a/.github/workflows/_go-tests.yml b/.github/workflows/_go-tests.yml
index 4131f630525..e5804737d7a 100644
--- a/.github/workflows/_go-tests.yml
+++ b/.github/workflows/_go-tests.yml
@@ -6,11 +6,11 @@ on:
 jobs:
   go-tests:
     name: Full Go tests (matrix)
-    runs-on: arbitrator-ci
+    runs-on: ${{ startsWith(matrix.test-mode, 'defaults') && 'ubuntu-24.04-8core' || 'ubuntu-latest' }}
     strategy:
       fail-fast: false
       matrix:
-        test-mode: [defaults-A, defaults-B, flaky, pathdb, challenge, stylus, l3challenge]
+        test-mode: [defaults-A, defaults-B, defaults-C, flaky, pathdb, challenge, stylus, l3challenge]
     services:
       redis:
         image: redis
@@ -35,7 +35,7 @@ jobs:
           echo "GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}" >> "$GITHUB_ENV"
 
       - name: Build
-        run: make -j8 build test-go-deps
+        run: make -j4 build test-go-deps
 
       - name: Build all lint dependencies
         run: make -j8 build-node-deps
@@ -66,7 +66,16 @@ jobs:
         run: >-
           ${{ github.workspace }}/.github/workflows/gotestsum.sh
           --tags cionly --timeout 60m --test_state_scheme hash
-          --junitfile test-results/junit-b.xml --skip '^Test[A-L]'
+          --junitfile test-results/junit-b.xml --run '^Test[M-S]'
+
+      - name: run tests without race detection and hash state scheme (C-batch)
+        if: matrix.test-mode == 'defaults-C'
+        id: run-tests-defaults-c
+        continue-on-error: true
+        run: >-
+          ${{ github.workspace }}/.github/workflows/gotestsum.sh
+          --tags cionly --timeout 60m --test_state_scheme hash
+          --junitfile test-results/junit-c.xml --skip '^Test[A-S]'
 
       - name: Process JUnit XML logs
         if: startsWith(matrix.test-mode, 'defaults') && always()
@@ -87,8 +96,9 @@ jobs:
 
       - name: run redis tests
         if: matrix.test-mode == 'defaults-A'
+        # TODO: figure out why TestRedisSeqCoordinatorPrioritiesFlaky fails
         run: >-
-          gotestsum --format short-verbose -- -p 1 -run TestRedis ./arbnode/... ./system_tests/...
+          gotestsum --format short-verbose -- -p 1 -run TestRedis -skip 'TestRedisForwarder|TestRedisProduce|TestRedisSeqCoordinatorPrioritiesFlaky' ./arbnode/... ./system_tests/...
           -coverprofile=coverage-redis.txt -covermode=atomic -coverpkg=./... -- --test_redis=redis://localhost:6379/0
 
       - name: Upload coverage to Codecov
diff --git a/.github/workflows/_tiitleChecker.yml b/.github/workflows/_tiitleChecker.yml
new file mode 100644
index 00000000000..32d5e7c60eb
--- /dev/null
+++ b/.github/workflows/_tiitleChecker.yml
@@ -0,0 +1,25 @@
+name: PR Title Lint
+run-name: Validate PR title (@${{ github.actor }})
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+on:
+  pull_request:
+
+jobs:
+  pr-title:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Validate PR title
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          TITLE=$(gh pr view ${{ github.event.pull_request.number }} --repo ${{ github.repository }} --json title --jq .title)
+          echo "PR title: $TITLE"
+
+          if ! echo "$TITLE" | grep -Eq '^(feat|fix|chore|docs|refactor|test|ci)(\(.+\))?: .+'; then
+            echo "❌ PR title must follow Conventional Commits"
+            exit 1
+          fi
diff --git a/.github/workflows/backport.yml b/.github/workflows/backport.yml
new file mode 100644
index 00000000000..adfa1427c7c
--- /dev/null
+++ b/.github/workflows/backport.yml
@@ -0,0 +1,53 @@
+name: Backport merged pull request
+on:
+  pull_request_target:
+    types: [closed]
+permissions:
+  contents: write # so it can comment
+  pull-requests: write # so it can create pull requests
+  issues: write # so it can create issues
+jobs:
+  backport:
+    name: Backport pull request
+    runs-on: ubuntu-latest
+    # Don't run on closed unmerged pull requests
+    if: github.event.pull_request.merged
+    steps:
+      - uses: actions/checkout@v4
+      - name: Create backport pull requests
+        id: backport
+        uses: korthout/backport-action@v3
+
+      - name: create issue if backport failed
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const pr = github.event.pull_request;
+            const byTarget = '${{ steps.backport.outputs.was_successful_by_target }}'
+              .split(' ')
+              .map(item => item.split('='))
+              .filter(arr => arr.length === 2);
+            const failedTargets = byTarget.filter(([label, ok]) => ok === 'false').map(([label]) => label);
+            const successfulTargets = byTarget.filter(([label, ok]) => ok === 'true').map(([label]) => label);
+
+            if (failedTargets.length === 0) {
+              // nothing failed — don't create an issue
+              return;
+            }
+
+            const title = `Backport failed for PR #${pr.number} to: ${failedTargets.join(', ')}`;
+            const body = `
+            Backport action failed for PR #${pr.number}.
+            - **Original PR:** #${pr.number} (${pr.title})
+            - **Failed targets:** ${failedTargets.length ? failedTargets.map(t => \`\\\`${t}\\\`\`).join(', ') : 'None'}
+            - **Successful targets:** ${successfulTargets.length ? successfulTargets.map(t => \`\\\`${t}\\\`\`).join(', ') : 'None'}
+            `;
+
+            await github.rest.issues.create({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              title,
+              body,
+              labels: ['backport-failure'],
+              assignees: [pr.user.login]
+            });
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 11fc35f7497..7c020632bb1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -55,7 +55,7 @@ jobs:
 
   can_proceed:
     name: can_proceed
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
     needs: [fast]
     steps:
       - name: OK
@@ -65,6 +65,6 @@ jobs:
     # This job is just to make sure that the "can_proceed" job's status is visible
     # on the pull request page, even if it is skipped due to all its dependencies being
     # skipped. It does not depend on any other jobs, so it always runs.
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
     steps:
       - run: true
diff --git a/.github/workflows/claude-review.yml b/.github/workflows/claude-review.yml
new file mode 100644
index 00000000000..3971ef34d4a
--- /dev/null
+++ b/.github/workflows/claude-review.yml
@@ -0,0 +1,95 @@
+name: Claude PR Review
+
+on:
+  pull_request:
+    types: [opened, ready_for_review, reopened]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  review:
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Remove project instructions
+        run: rm -f CLAUDE.md AGENTS.md
+
+      - name: Fetch team review comments
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN}}
+        run: |
+          mkdir -p ./tmp
+          scripts/fetch-pr-team-comments \
+            "${{ github.repository_owner }}" \
+            "${{ github.event.repository.name }}" \
+            "${{ github.event.pull_request.number }}" \
+            > ./tmp/pr-review-comments.json
+
+      - name: Claude Code Review
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          track_progress: true
+          prompt: |
+            REPO: ${{ github.repository }}
+            PR NUMBER: ${{ github.event.pull_request.number }}
+
+            Perform a comprehensive code review with the following focus areas:
+
+            1. **Code Quality**
+               - Clean code principles and best practices
+               - Proper error handling and edge cases
+               - Code readability and maintainability
+
+            2. **Security**
+               - Check for potential security vulnerabilities
+               - Validate input sanitization
+               - Review authentication/authorization logic
+
+            3. **Performance**
+               - Identify potential performance bottlenecks
+               - Review database queries for efficiency
+               - Check for memory leaks or resource issues
+
+            4. **Testing**
+               - Verify adequate test coverage
+               - Review test quality and edge cases
+               - Check for missing test scenarios
+
+            5. **Documentation**
+               - Ensure code is properly documented
+               - Verify README updates for new features
+               - Check API documentation accuracy
+
+            Before reviewing, read existing comments from `./tmp/pr-review-comments.json`.
+            - Do not duplicate feedback already given by any reviewer.
+            - For your own unresolved review threads: respond to any changes or replies, then resolve if the issue is fixed, explained, or answered satisfactorily.
+              `gh api graphql -f query='mutation { resolveReviewThread(input: {threadId: "<thread_id>"}) { thread { isResolved } } }'`
+            - Only resolve your own threads, never others'.
+
+            Do NOT comment on:
+            - `todo!()` or `// TODO` -- these are intentional, just factor them into your understanding
+            - Unnecessary clones or clone optimization suggestions
+            - Unused code, fields, or parameters -- clippy catches these, and `_` prefixed names are intentionally unused
+
+            Provide detailed feedback using inline comments for specific issues.
+            Use top-level comments for general observations or praise.
+          # Allowed tools (minimal permissions):
+          #   mcp__github_inline_comment__create_inline_comment - post inline code comments
+          #   gh pr comment  - post top-level PR comments
+          #   gh pr diff     - read PR diff
+          #   gh pr view     - read PR metadata
+          #   gh api */pulls/*/comments  - reply to review thread comments
+          #   gh api graphql mutation resolveReviewThread - resolve own review threads
+          claude_args: |
+            --model claude-opus-4-6 --allowedTools "mcp__github_inline_comment__create_inline_comment,Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*),Bash(gh api */pulls/*/comments*),Bash(gh api graphql -f query='mutation { resolveReviewThread*)"
diff --git a/.github/workflows/claude.yml b/.github/workflows/claude.yml
new file mode 100644
index 00000000000..5f3a68585a7
--- /dev/null
+++ b/.github/workflows/claude.yml
@@ -0,0 +1,39 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  pull_request_review:
+    types: [submitted]
+  issues:
+    types: [opened, assigned]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.issue.number || github.event.pull_request.number || github.run_id }}
+  cancel-in-progress: false
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+      id-token: write
+      actions: read
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          claude_args: "--model claude-opus-4-6 --max-turns 15"
diff --git a/.github/workflows/espresso-caff-node-e2e.yml b/.github/workflows/espresso-caff-node-e2e.yml
new file mode 100644
index 00000000000..d40bcc5f63b
--- /dev/null
+++ b/.github/workflows/espresso-caff-node-e2e.yml
@@ -0,0 +1,42 @@
+name: Espresso E2E Caff Node test CI
+
+on:
+  workflow_dispatch:
+  merge_group:
+  pull_request:
+  push:
+    branches:
+      - integration
+      - celestia-integration
+      - integration-v3.9.2
+      - celestia-v3.9.2
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    name: Espresso E2E
+    runs-on: ubuntu-24.04-8core
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+        with:
+          submodules: recursive
+
+      - name: Setup CI
+        uses: ./.github/actions/ci-setup
+
+      - name: Build
+        run: make build build-replay-env -j
+
+      - name: Install docker-compose
+        uses: KengoTODA/actions-setup-docker-compose@v1.2.1
+        with:
+          version: "2.22.0"
+
+      - name: Run Espresso Caff Node tests
+        run: |
+          bash scripts/run-espresso-caff-node-ci-tests
diff --git a/.github/workflows/espresso-docker.yml b/.github/workflows/espresso-docker.yml
new file mode 100644
index 00000000000..747331819fd
--- /dev/null
+++ b/.github/workflows/espresso-docker.yml
@@ -0,0 +1,78 @@
+# Build the nitro-node images on  AMD64 hosts.
+# After building, the images are merged together to make a multiplatform image.
+name: Espresso Docker build CI
+run-name: Docker build CI triggered from @${{ github.actor }} of ${{ github.head_ref }}
+
+on:
+  workflow_dispatch:
+  merge_group:
+  pull_request:
+  push:
+    tags:
+      - "v*"
+    branches:
+      - integration
+      - celestia-integration
+      - integration-v3.9.2
+      - celestia-v3.9.2
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  docker_build:
+    strategy:
+      matrix:
+        platform: [linux/amd64]
+
+    runs-on: ubuntu-24.04-8core
+
+    steps:
+      - uses: cargo-bins/cargo-binstall@main
+
+      - name: Fix submodule permissions check
+        run: |
+          git config --global --add safe.directory '*'
+
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Github Container Repo
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner  }}
+          password: ${{ secrets.GITHUB_TOKEN  }}
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ghcr.io/espressosystems/nitro-espresso-integration/nitro-node
+          tags: |
+            type=ref,event=pr
+            type=ref,event=branch
+            type=ref,event=tag
+            type=sha
+
+      - name: Build & push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: Dockerfile
+          target: nitro-node
+          platforms: linux/amd64
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+
+      - name: Check available space after CI run
+        if: "!cancelled()"
+        run: |
+          sudo df -h
diff --git a/.github/workflows/espresso-poster-e2e.yml b/.github/workflows/espresso-poster-e2e.yml
new file mode 100644
index 00000000000..c50162504b6
--- /dev/null
+++ b/.github/workflows/espresso-poster-e2e.yml
@@ -0,0 +1,42 @@
+name: Espresso E2E Batch Poster test CI
+
+on:
+  workflow_dispatch:
+  merge_group:
+  pull_request:
+  push:
+    branches:
+      - integration
+      - celestia-integration
+      - integration-v3.9.2
+      - celestia-v3.9.2
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    name: Espresso E2E
+    runs-on: ubuntu-24.04-8core
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+        with:
+          submodules: recursive
+
+      - name: Setup CI
+        uses: ./.github/actions/ci-setup
+
+      - name: Build
+        run: make build build-replay-env -j
+
+      - name: Install docker-compose
+        uses: KengoTODA/actions-setup-docker-compose@v1.2.1
+        with:
+          version: "2.22.0"
+
+      - name: Run Espresso Batch Poster tests
+        run: |
+          bash scripts/run-espresso-batch-poster-ci-tests
diff --git a/.github/workflows/espresso-regression.yml b/.github/workflows/espresso-regression.yml
new file mode 100644
index 00000000000..33dadcb24e5
--- /dev/null
+++ b/.github/workflows/espresso-regression.yml
@@ -0,0 +1,88 @@
+name: Espresso Regression test CI
+
+on:
+  workflow_run:
+    workflows: ["Espresso Docker build CI"]
+    types: [completed]
+
+  workflow_dispatch:
+    inputs:
+      image:
+          type: choice
+          default: dev
+          required: true
+          description: "Image to use for the regression test"
+          options:
+              - dev # build from source
+              - custom # use custom image
+      custom_image: # please make sure this image is compatible with the nitro-testnode submodule
+          type: string
+          required: false
+          description: "Custom image to use for the regression test"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  debug:
+    name: Output variables
+    runs-on: ubuntu-latest
+    steps:
+      - name: Output variables
+        run: |
+          echo "github.event_name=${{ github.event_name }}"
+          echo "github.event.workflow_run.ref=${{ github.event.workflow_run.ref }}"
+          echo "github.event.workflow_run.head_branch=${{ github.event.workflow_run.head_branch }}"
+
+  throughtput:
+    name: Throughput test
+    runs-on: ubuntu-24.04-8core
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Setup CI
+        uses: ./.github/actions/ci-setup
+
+      - name: Build
+        run: make build build-replay-env -j
+
+      - name: Transaction Streamer regression test
+        run: |
+          bash scripts/run-transaction-streamer-regression-ci-tests
+
+
+  nitro-testnode:
+    name: Espresso Regression test
+    runs-on: ubuntu-24.04-8core
+    if: github.event_name == 'workflow_dispatch' || (github.event_name == 'workflow_run' && startsWith(github.event.workflow_run.head_branch, 'v'))
+    steps:
+      - name: Setup environment variables
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_run" ]; then
+            TAG_NAME=${{ github.event.workflow_run.head_branch }}
+            echo "ESPRESSO_VERSION=ghcr.io/espressosystems/nitro-espresso-integration/nitro-node:$TAG_NAME" >> $GITHUB_ENV
+          elif [ "${{ github.event.workflow_dispatch.inputs.image }}" = "custom" ]; then
+            echo "ESPRESSO_VERSION=${{ github.event.workflow_dispatch.inputs.custom_image }}" >> $GITHUB_ENV
+          else
+            echo "ESPRESSO_DEV=true" >> $GITHUB_ENV
+          fi
+
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Run regression test
+        run: |
+          echo "ESPRESSO_VERSION=${{ env.ESPRESSO_VERSION }}"
+          echo "ESPRESSO_DEV=${{ env.ESPRESSO_DEV }}"
+          if [ -z "$ESPRESSO_VERSION" ] && [ -z "$ESPRESSO_DEV" ]; then
+            echo "Neither ESPRESSO_VERSION nor ESPRESSO_DEV is set. Exiting."
+            exit 1
+          fi
+          cd nitro-testnode
+          ./regression-test.bash
diff --git a/.github/workflows/gotestsum.sh b/.github/workflows/gotestsum.sh
index 2e1e4494fc0..fc5156b7873 100755
--- a/.github/workflows/gotestsum.sh
+++ b/.github/workflows/gotestsum.sh
@@ -96,6 +96,11 @@ fi
 # Append the separator and go test arguments
 cmd="$cmd --"
 
+### Espresso
+
+espresso_skip_tests=$(grep -vE '^\s*#|^\s*$' ci_skip_tests | tr '\n' '|' | sed 's/|$//')
+###
+
 if [ "$timeout" != "" ]; then
   cmd="$cmd -timeout $timeout"
 fi
@@ -108,6 +113,8 @@ if [ "$run" != "" ]; then
   cmd="$cmd -run=\"$run\""
 fi
 
+skip="$skip|$espresso_skip_tests"
+
 if [ "$skip" != "" ] && [ "$flaky" == false ]; then
   cmd="$cmd -skip=\"$skip|Flaky\""
 elif [ "$skip" != "" ]; then
@@ -121,7 +128,9 @@ if [ "$race" == true ]; then
 fi
 
 if [ "$cover" == true ]; then
-  cmd="$cmd -coverprofile=coverage.txt -covermode=atomic -coverpkg=./...,./go-ethereum/..."
+  # Espresso: we don't run coverage for now
+  # cmd="$cmd -coverprofile=coverage.txt -covermode=atomic -coverpkg=./...,./go-ethereum/..."
+  cmd="$cmd"
 fi
 
 if [ "$test_state_scheme" != "" ]; then
diff --git a/.github/workflows/nightly-ci.yml b/.github/workflows/nightly-ci.yml
deleted file mode 100644
index 9b00c53ba81..00000000000
--- a/.github/workflows/nightly-ci.yml
+++ /dev/null
@@ -1,128 +0,0 @@
----
-name: Nightly CI
-run-name: Nightly CI tests triggered from @${{ github.actor }} of ${{ github.head_ref }}
-
-on:
-  workflow_dispatch:
-  schedule:
-    # Run at 00:00 AM UTC
-    - cron: '0 0 * * *'
-
-jobs:
-  # Only run on schedule
-  tests-scheduled:
-    name: Scheduled tests
-    runs-on: arbitrator-ci
-
-    services:
-      redis:
-        image: redis
-        ports:
-          - 6379:6379
-
-    strategy:
-      fail-fast: false
-      matrix:
-        test-mode: [legacychallenge, long, challenge, l3challenge, execution-spec-tests]
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-        with:
-          submodules: recursive
-
-      - name: Setup CI
-        uses: ./.github/actions/ci-setup
-
-      - name: Build
-        run: make build test-go-deps -j
-
-      - name: Build all lint dependencies
-        run: make -j build-node-deps
-
-      - name: Lint
-        uses: golangci/golangci-lint-action@v9
-        with:
-          version: latest
-          skip-cache: true
-          skip-save-cache: true
-
-      - name: Custom Lint
-        run: |
-          go run ./linters ./...
-
-      - name: Set environment variables
-        run: |
-          mkdir -p target/tmp/deadbeefbee
-          echo "TMPDIR=$(pwd)/target/tmp/deadbeefbee" >> "$GITHUB_ENV"
-          echo "GOMEMLIMIT=6GiB" >> "$GITHUB_ENV"
-          echo "GOGC=80" >> "$GITHUB_ENV"
-          echo "GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}" >> "$GITHUB_ENV"
-
-      - name: run tests with race detection and hash state scheme
-        if: matrix.test-mode == 'race'
-        run: |
-          echo "Running tests with Hash Scheme" >> full.log
-          ${{ github.workspace }}/.github/workflows/gotestsum.sh --race --timeout 90m --test_state_scheme hash
-
-      - name: run challenge tests
-        if: matrix.test-mode == 'challenge'
-        run: >-
-          ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags challengetest
-          --run TestChallenge --timeout 120m --cover
-
-      - name: run L3 challenge tests
-        if: matrix.test-mode == 'l3challenge'
-        run: >-
-          ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags challengetest
-          --run TestL3Challenge --timeout 120m --cover
-
-      - name: run legacy challenge tests
-        if: matrix.test-mode == 'legacychallenge'
-        run: >-
-          ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags legacychallengetest
-          --run TestChallenge --timeout 60m --cover
-
-      - name: run long stylus tests
-        if: matrix.test-mode == 'long'
-        run: >-
-          ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags stylustest
-          --run TestProgramLong --timeout 60m --cover
-
-      - name: run execution spec tests
-        if: matrix.test-mode == 'execution-spec-tests'
-        run: ${{ github.workspace }}/.github/workflows/runExecutionSpecTests.sh
-
-      - name: Archive detailed run log
-        uses: actions/upload-artifact@v5
-        with:
-          name: ${{ matrix.test-mode }}-full.log
-          path: full.log
-
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v5
-        with:
-          fail_ci_if_error: false
-          files: ./coverage.txt,./coverage-redis.txt
-          verbose: false
-          token: ${{ secrets.CODECOV_TOKEN }}
-
-  notify-on-failure:
-    name: Notify Slack on failure
-    needs: [tests-scheduled]
-    runs-on: ubuntu-4
-    if: ${{ failure() }}
-    env:
-      RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
-    steps:
-      - name: Send Slack notification
-        uses: slackapi/slack-github-action@v2.1.1
-        with:
-          errors: true
-          method: chat.postMessage
-          token: ${{ secrets.SLACK_BOT_TOKEN }}
-          payload: |
-            {
-              "channel": "${{ secrets.SLACK_CHANNEL_ID }}",
-              "text": "⚠️ CI job failed! ${{ env.RUN_URL }}",
-            }
diff --git a/.github/workflows/release-please.yml b/.github/workflows/release-please.yml
new file mode 100644
index 00000000000..8e9b28679f4
--- /dev/null
+++ b/.github/workflows/release-please.yml
@@ -0,0 +1,46 @@
+name: Release Please
+
+on:
+  push:
+    branches:
+      - integration-v3.9.8
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+      tag_name: ${{ steps.release.outputs.tag_name }}
+      version: ${{ steps.release.outputs.version }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Run Release Please
+        id: release
+        uses: googleapis/release-please-action@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+          target-branch: integration-v3.9.8
+
+      - name: Output release info
+        if: ${{ steps.release.outputs.release_created }}
+        run: |
+          echo "Release created: ${{ steps.release.outputs.tag_name }}"
+          echo "Version: ${{ steps.release.outputs.version }}"
+
+      - name: Normalize release title to full tag
+        if: ${{ steps.release.outputs.release_created == 'true' }}
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release edit "${{ steps.release.outputs.tag_name }}" \
+            --repo "${{ github.repository }}" \
+            --title "${{ steps.release.outputs.tag_name }}"
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 00000000000..1827240c390
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,133 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*-espresso-v*"
+
+permissions:
+  contents: write
+  packages: write
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: espressosystems/nitro-espresso-integration/nitro-node
+
+jobs:
+  build-and-release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver-opts: network=host
+
+      - name: Log in to Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Parse version from tag
+        id: version
+        run: |
+          # Tag format: v3.9.8-espresso-v0.1.0
+          TAG=${GITHUB_REF#refs/tags/}
+
+          # Extract upstream version (3.9.8)
+          UPSTREAM=$(echo "$TAG" | sed 's/^v\(.*\)-espresso-v.*/\1/')
+
+          # Extract espresso version (0.1.0)
+          ESPRESSO=$(echo "$TAG" | sed 's/.*-espresso-v//')
+
+          # Full version without leading 'v' (3.9.8-espresso-0.1.0)
+          FULL_VERSION="${UPSTREAM}-espresso-${ESPRESSO}"
+
+          echo "tag=$TAG" >> $GITHUB_OUTPUT
+          echo "upstream=$UPSTREAM" >> $GITHUB_OUTPUT
+          echo "espresso=$ESPRESSO" >> $GITHUB_OUTPUT
+          echo "full_version=$FULL_VERSION" >> $GITHUB_OUTPUT
+
+          echo "Tag: $TAG"
+          echo "Upstream: $UPSTREAM"
+          echo "Espresso: $ESPRESSO"
+
+      - name: Extract metadata for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=raw,value=${{ steps.version.outputs.full_version }}
+            type=raw,value=${{ steps.version.outputs.upstream }}-espresso-latest
+            type=raw,value=latest,enable=${{ !contains(github.ref, 'rc') && !contains(github.ref, 'alpha') && !contains(github.ref, 'beta') }}
+
+      - name: Cache Docker layers
+        uses: actions/cache@v3
+        with:
+          path: /tmp/.buildx-cache
+          key: ${{ runner.os }}-buildx-release-${{ hashFiles('Dockerfile') }}
+          restore-keys: ${{ runner.os }}-buildx-release-
+
+      - name: Build and push nitro-node
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          target: nitro-node
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+          build-args: |
+            NITRO_VERSION=${{ steps.version.outputs.full_version }}
+            NITRO_DATETIME=${{ github.event.head_commit.timestamp }}
+
+      - name: Generate release notes from changelog
+        id: release-notes
+        run: |
+          ESPRESSO="${{ steps.version.outputs.espresso }}"
+          TAG="${{ steps.version.outputs.tag }}"
+
+          # Extract content between this version header and the next version header
+          awk -v ver="$ESPRESSO" '
+            /^## \[/ { if (found) exit; if (index($0, ver)) found=1; next }
+            found { print }
+          ' CHANGELOG.md > release-notes.md
+
+          # If no changelog entry found, create a basic one
+          if [ ! -s release-notes.md ]; then
+            echo "Release $TAG" > release-notes.md
+          fi
+
+          # Append Docker image details
+          echo "" >> release-notes.md
+          echo "---" >> release-notes.md
+          echo "" >> release-notes.md
+          echo "### Docker Images" >> release-notes.md
+          echo "" >> release-notes.md
+          echo "\`\`\`bash" >> release-notes.md
+          echo "docker pull ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.full_version }}" >> release-notes.md
+          echo "\`\`\`" >> release-notes.md
+
+      - name: Update GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ steps.version.outputs.tag }}
+          name: Release ${{ steps.version.outputs.tag }}
+          body_path: release-notes.md
+          draft: false
+          prerelease: ${{ contains(github.ref, 'rc') || contains(github.ref, 'alpha') || contains(github.ref, 'beta') }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Move cache
+        run: |
+          rm -rf /tmp/.buildx-cache
+          mv /tmp/.buildx-cache-new /tmp/.buildx-cache
diff --git a/.gitignore b/.gitignore
index fa765f351ac..0343ec36a53 100644
--- a/.gitignore
+++ b/.gitignore
@@ -40,3 +40,7 @@ tmp/*
 .env
 go.work
 go.work.sum
+
+!system_tests/espresso-e2e/.env
+/.pre-commit-config.yaml
+.direnv
diff --git a/.gitmodules b/.gitmodules
index b79aef2d69b..b0795e347c1 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,6 +1,7 @@
 [submodule "go-ethereum"]
 	path = go-ethereum
-	url = https://github.com/OffchainLabs/go-ethereum.git
+	url = https://github.com/EspressoSystems/go-ethereum
+	branch = integration-v3.9.2
 [submodule "arbitrator/wasm-libraries/soft-float/SoftFloat"]
 	path = arbitrator/wasm-libraries/soft-float/SoftFloat
 	url = https://github.com/OffchainLabs/SoftFloat.git
@@ -9,8 +10,8 @@
 	url = https://github.com/google/brotli.git
 [submodule "contracts"]
 	path = contracts
-	url = https://github.com/OffchainLabs/nitro-contracts.git
-	branch = develop
+	url = git@github.com:EspressoSystems/nitro-contracts.git
+	branch = v3.1.1
 [submodule "arbitrator/wasm-testsuite/testsuite"]
 	path = arbitrator/wasm-testsuite/testsuite
 	url = https://github.com/WebAssembly/testsuite.git
@@ -19,7 +20,8 @@
 	url = https://github.com/OffchainLabs/wasmer.git
 [submodule "nitro-testnode"]
 	path = nitro-testnode
-	url = https://github.com/OffchainLabs/nitro-testnode.git
+	url = https://github.com/EspressoSystems/nitro-testnode
+	branch = integration
 [submodule "arbitrator/langs/rust"]
 	path = arbitrator/langs/rust
 	url = https://github.com/OffchainLabs/stylus-sdk-rs.git
@@ -34,10 +36,14 @@
 	url = https://github.com/safe-global/safe-smart-account.git
 [submodule "contracts-legacy"]
 	path = contracts-legacy
-	url = https://github.com/OffchainLabs/nitro-contracts.git
+	url = git@github.com:EspressoSystems/nitro-contracts.git
+	branch = 2.1.3-legacy
 [submodule "contracts-local/lib/openzeppelin-contracts"]
 	path = contracts-local/lib/openzeppelin-contracts
 	url = https://github.com/OpenZeppelin/openzeppelin-contracts
 [submodule "contracts-local/src/precompiles"]
 	path = contracts-local/src/precompiles
 	url = https://github.com/OffchainLabs/nitro-precompile-interfaces.git
+[submodule "espresso-tee-contracts"]
+	path = espresso-tee-contracts
+	url = https://github.com/EspressoSystems/espresso-tee-contracts
diff --git a/.golangci.yml b/.golangci.yml
index 21ff49c7ab0..812dcdf3899 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -55,6 +55,7 @@ linters:
       - third_party$
       - builtin$
       - examples$
+      - espressotee/legacy
 formatters:
   enable:
     - gci
@@ -74,3 +75,4 @@ formatters:
       - third_party$
       - builtin$
       - examples$
+      - espressotee/legacy
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
new file mode 100644
index 00000000000..5fdd88304ed
--- /dev/null
+++ b/.release-please-manifest.json
@@ -0,0 +1,3 @@
+{
+  ".": "1.1.0"
+}
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000000..06d8bbc068d
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,59 @@
+# Project overview
+This project is a clone of offchain's labs [nitro](https://github.com/OffchainLabs/nitro/) Branches in our repository are typically forked from specific upstream Nitro versions. For example, a branch named integration-v3.9.2 indicates that it was forked from Nitro version v3.9.2. Our integration integrates nitro's code with [Espresso Network ](https://docs.espressosys.com/) to help nitro chains achieve fast finality. 
+
+Majority of our changes are in the following files:
+- all files under `espresso/` folder
+- `batch_poster.go`
+- `arbnode/espresso_caff_node.go`
+
+All our tests include the prefix `TestEspresso` and `TestAuthDB`
+
+# Build and test commands
+To build the code:
+```
+make clean && make build
+```
+
+To run our tests:
+
+```
+gotestsum \
+    --format short-verbose \
+    --packages="./..." \
+    --rerun-fails=1 \
+    -- \
+    -v \
+    -timeout 45m \
+    -p 1 \
+    -parallel 1 \
+    -run 'TestEspresso'
+```
+
+```
+gotestsum \
+    --format short-verbose \
+    --packages="github.com/offchainlabs/nitro/espresso/authdb" \
+    -- \
+    -v \
+    -timeout 5m \
+    -p 1 \
+    ./espresso/authdb... \
+    -run 'TestAuthDB'
+```
+
+# Code style guidelines
+- Avoid unnecessary comments when the code is self-explanatory through clear function and variable names.
+- All tests should start with the TestEspresso prefix.
+- No changes should be made to the submodules.
+- Avoid making changes to the Rollup code outside of the espresso folder.
+- Lint fixes should be in separate, individual commits. To run lint, use make lint.
+
+# Testing
+This is blockchain infrastructure. Bugs can cause irreversible financial losses.
+
+- Correctness over coverage: Tests must prove the code is correct, not just hit line counts
+- Requirements traceability: Each requirement should have corresponding test(s)
+- Edge cases are mandatory: Boundary conditions, error paths, adversarial inputs
+
+# Security considerations
+- Dont read any environment variable file ( *.env, .env)
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 00000000000..9bfe1b9c2f4
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,48 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Versioning Scheme
+
+This project uses compound versioning: `v{upstream}-espresso-v{espresso}`
+
+- **Upstream version**: Tracks the base Nitro version from upstream
+- **Espresso version**: Tracks Espresso-specific changes (auto-incremented)
+
+Example: `v3.9.8-espresso-v0.1.0`
+
+---
+
+## [1.1.0](https://github.com/EspressoSystems/nitro-espresso-integration/compare/v3.9.8-espresso-v1.0.0...v3.9.8-espresso-v1.1.0) (2026-05-01)
+
+
+### Features
+
+* remove legacy code ([#1041](https://github.com/EspressoSystems/nitro-espresso-integration/issues/1041)) ([0bfe79f](https://github.com/EspressoSystems/nitro-espresso-integration/commit/0bfe79f253801ea9ec43e9a568cec98074ca2d37))
+
+
+### Bug Fixes
+
+* reject TESTS tee type with production service type ([#1040](https://github.com/EspressoSystems/nitro-espresso-integration/issues/1040)) ([c785a71](https://github.com/EspressoSystems/nitro-espresso-integration/commit/c785a7128908a5c93fc836fb9d705dd96de43a98))
+
+## 1.0.0 (2026-04-16)
+
+
+### Features
+
+* Upgrade to v3.9.8 ([#1030](https://github.com/EspressoSystems/nitro-espresso-integration/issues/1030)) ([249a357](https://github.com/EspressoSystems/nitro-espresso-integration/commit/249a3572d349d144e70e1226523f6c76622f76de))
+
+
+### Bug Fixes
+
+* fix nonce validation ([#1021](https://github.com/EspressoSystems/nitro-espresso-integration/issues/1021)) ([#1031](https://github.com/EspressoSystems/nitro-espresso-integration/issues/1031)) ([a97127e](https://github.com/EspressoSystems/nitro-espresso-integration/commit/a97127eb47530165059e1a0f44bd7b7895a1f69c))
+* espresso caff node test ([#1035](https://github.com/EspressoSystems/nitro-espresso-integration/issues/1035)) ([cf2530f](https://github.com/EspressoSystems/nitro-espresso-integration/commit/cf2530ffe0754598621942d18f7195fdda73911c))
+* release pipeline for v3.9.8 ([#1036](https://github.com/EspressoSystems/nitro-espresso-integration/issues/1036)) ([400c412](https://github.com/EspressoSystems/nitro-espresso-integration/commit/400c4129c284e55728e6e2404fe0258b26f75dda))
+
+
+---
+
+<!-- Release-Please will add new entries above this line -->
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 120000
index 00000000000..47dc3e3d863
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+AGENTS.md
\ No newline at end of file
diff --git a/CODEOWNERS b/CODEOWNERS
new file mode 100644
index 00000000000..277df69b1ba
--- /dev/null
+++ b/CODEOWNERS
@@ -0,0 +1,5 @@
+# These owners will be the default owners for everything in the repo. Unless a
+# later match takes precedence, they will be requested for review when someone
+# opens a pull request.
+
+*      @ImJeremyHe @zacshowa @Sneh1999 @philippecamacho @jbearer @jjeangal @varun-doshi
diff --git a/Dockerfile b/Dockerfile
index 04efd9a6ef2..5e6b8f58837 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -37,6 +37,7 @@ COPY contracts-legacy contracts-legacy/
 COPY contracts-local contracts-local/
 COPY contracts contracts/
 COPY safe-smart-account safe-smart-account/
+COPY espresso-tee-contracts espresso-tee-contracts/
 RUN cd safe-smart-account && npm install
 COPY Makefile .
 RUN . ~/.bashrc && NITRO_BUILD_IGNORE_TIMESTAMPS=1 make build-solidity
@@ -98,6 +99,7 @@ COPY ./contracts-local/lib/ ./contracts-local/lib/
 COPY ./contracts/src/precompiles/ ./contracts/src/precompiles/
 COPY ./contracts/package.json ./contracts/yarn.lock ./contracts/
 COPY ./safe-smart-account ./safe-smart-account
+COPY ./espresso-tee-contracts ./espresso-tee-contracts
 COPY ./solgen/gen.go ./solgen/
 COPY ./go-ethereum ./go-ethereum
 COPY scripts/remove_reference_types.sh scripts/
@@ -207,6 +209,7 @@ COPY ./contracts ./contracts
 COPY ./contracts-legacy ./contracts-legacy
 COPY ./contracts-local ./contracts-local
 COPY ./safe-smart-account ./safe-smart-account
+COPY ./espresso-tee-contracts ./espresso-tee-contracts
 RUN NITRO_BUILD_IGNORE_TIMESTAMPS=1 make build-replay-env
 
 FROM debian:bookworm-slim AS machine-versions
@@ -272,6 +275,7 @@ COPY --from=contracts-builder workspace/contracts-legacy/build/ contracts-legacy
 COPY --from=contracts-builder workspace/contracts-legacy/out/ contracts-legacy/out/
 COPY --from=contracts-builder workspace/contracts-local/out/ contracts-local/out/
 COPY --from=contracts-builder workspace/safe-smart-account/build/ safe-smart-account/build/
+COPY --from=contracts-builder workspace/espresso-tee-contracts/out/ espresso-tee-contracts/out/
 COPY --from=contracts-builder workspace/.make/ .make/
 COPY --from=prover-header-export / target/
 COPY --from=brotli-library-export / target/
diff --git a/Makefile b/Makefile
index 3b26d0b1226..af7f91b5138 100644
--- a/Makefile
+++ b/Makefile
@@ -43,6 +43,13 @@ precompile_names = AddressTable Aggregator BLS Debug FunctionTable GasInfo Info
 precompiles = $(patsubst %,./solgen/generated/%.go, $(precompile_names))
 
 output_root=target
+export PKG_CONFIG_PATH=$(abspath $(output_root)/pkgconfig)
+# For nix pkg-config
+ifdef IN_NIX_SHELL
+  export PKG_CONFIG_PATH_FOR_TARGET := $(abspath $(output_root)/pkgconfig):$(PKG_CONFIG_PATH_FOR_TARGET)
+endif
+
+sed_escaped_output_root:=$(subst /,\/,$(output_root))
 output_latest=$(output_root)/machines/latest
 
 repo_dirs = arbos arbcompress arbnode arbutil arbstate cmd das precompiles solgen system_tests util validator wavmio
@@ -290,10 +297,14 @@ clean:
 	rm -f arbitrator/wasm-libraries/forward/*.wat
 	rm -rf arbitrator/stylus/tests/*/target/ arbitrator/stylus/tests/*/*.wasm
 	rm -rf brotli/buildfiles
-	@rm -rf contracts/build contracts/cache solgen/go/
-	@rm -rf contracts-legacy/build contracts-legacy/cache
-	@rm -rf contracts-local/out contracts-local/forge-cache
-	@rm -f .make/*
+	rm -rf contracts/build contracts/cache solgen/go/
+	rm -rf contracts-legacy/build contracts-legacy/cache contracts-legacy/out
+	rm -rf contracts-local/out contracts-local/forge-cache
+	rm -f .make/*
+	rm -rf brotli/buildfiles
+	# Ensure lib64 is a symlink to lib
+	mkdir -p $(output_root)/lib
+	ln -s lib $(output_root)/lib64
 
 .PHONY: docker
 docker:
@@ -601,22 +612,42 @@ contracts/test/prover/proofs/%.json: $(arbitrator_cases)/%.wasm $(prover_bin)
 	cargo test --manifest-path arbitrator/Cargo.toml --release
 	@touch $@
 
-.make/solgen: $(DEP_PREDICATE) solgen/gen.go .make/solidity $(ORDER_ONLY_PREDICATE) .make
+.make/solgen: $(DEP_PREDICATE) solgen/gen.go .make/solidity .make/espresso-gen $(ORDER_ONLY_PREDICATE) .make
 	mkdir -p solgen/go/
 	go run solgen/gen.go
 	@touch $@
 
+.make/espresso-gen: $(DEP_PREDICATE) espresso-tee-contracts/bindings/gen.go .make/solidity $(ORDER_ONLY_PREDICATE) .make
+	mkdir -p espresso-tee-contracts/espressogen/
+	go run -modfile ./espresso-tee-contracts/bindings/go.mod ./espresso-tee-contracts/bindings/gen.go
+	@touch $@
+
 .make/solidity: $(DEP_PREDICATE) safe-smart-account/contracts/*/*.sol safe-smart-account/contracts/*.sol contracts/src/*/*.sol contracts-legacy/src/*/*.sol contracts-local/src/*/*.sol contracts-local/gas-dimensions/src/*.sol .make/yarndeps $(ORDER_ONLY_PREDICATE) .make
 	npm --prefix safe-smart-account run build
 	yarn --cwd contracts build
 	yarn --cwd contracts build:forge:yul
 	yarn --cwd contracts-legacy build
 	yarn --cwd contracts-legacy build:forge:yul
+	cd espresso-tee-contracts && forge build && cd ../
 	+make -C contracts-local build
 	@touch $@
 
 .make/yarndeps: $(DEP_PREDICATE) */package.json */yarn.lock $(ORDER_ONLY_PREDICATE) .make
-	npm --prefix safe-smart-account install
+	npm --prefix safe-smart-account install -D \
+  		"@nomicfoundation/hardhat-chai-matchers@^2.0.0" \
+  		"@nomicfoundation/hardhat-ethers@^3.0.0" \
+  		"@nomicfoundation/hardhat-ignition-ethers@^0.15.0" \
+  		"@nomicfoundation/hardhat-network-helpers@^1.0.0" \
+  		"@nomicfoundation/hardhat-verify@^2.0.0" \
+  		"@typechain/ethers-v6@^0.5.0" \
+  		"@typechain/hardhat@^9.0.0" \
+  		"chai@^4.2.0" \
+  		"ethers@^6.14.0" \
+  		"hardhat-gas-reporter@^2.3.0" \
+  		"solidity-coverage@^0.8.1" \
+  		"typechain@^8.3.0" \
+		"@nomicfoundation/hardhat-ignition@^0.15.15" \
+  		"@nomicfoundation/ignition-core@^0.15.14"
 	yarn --cwd contracts install
 	yarn --cwd contracts-legacy install
 	+make -C contracts-local install
diff --git a/arbitrator/stylus/tests/.cargo/config.toml b/arbitrator/stylus/tests/.cargo/config.toml
index 6ca5e18651c..db278ee0b40 100644
--- a/arbitrator/stylus/tests/.cargo/config.toml
+++ b/arbitrator/stylus/tests/.cargo/config.toml
@@ -1,5 +1,6 @@
 [build]
 target = "wasm32-unknown-unknown"
+jobs = 2
 
 [target.wasm32-unknown-unknown]
 rustflags = [
diff --git a/arbnode/batch_poster.go b/arbnode/batch_poster.go
index 20ed5fe69dd..717f7c31ea2 100644
--- a/arbnode/batch_poster.go
+++ b/arbnode/batch_poster.go
@@ -16,6 +16,7 @@ import (
 	"sync/atomic"
 	"time"
 
+	hotshotClient "github.com/EspressoSystems/espresso-network/sdks/go/client"
 	"github.com/andybalholm/brotli"
 	"github.com/spf13/pflag"
 
@@ -44,6 +45,11 @@ import (
 	"github.com/offchainlabs/nitro/cmd/chaininfo"
 	"github.com/offchainlabs/nitro/cmd/genericconf"
 	"github.com/offchainlabs/nitro/daprovider"
+	"github.com/offchainlabs/nitro/espresso/authdb"
+	espresso_key_manager "github.com/offchainlabs/nitro/espresso/key-manager"
+	"github.com/offchainlabs/nitro/espresso/submitter"
+	"github.com/offchainlabs/nitro/espressostreamer"
+	"github.com/offchainlabs/nitro/espressotee"
 	"github.com/offchainlabs/nitro/execution"
 	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
 	"github.com/offchainlabs/nitro/util"
@@ -51,6 +57,7 @@ import (
 	"github.com/offchainlabs/nitro/util/blobs"
 	"github.com/offchainlabs/nitro/util/headerreader"
 	"github.com/offchainlabs/nitro/util/redisutil"
+	"github.com/offchainlabs/nitro/util/signature"
 	"github.com/offchainlabs/nitro/util/stopwaiter"
 )
 
@@ -81,16 +88,21 @@ var (
 const (
 	batchPosterSimpleRedisLockKey = "node.batch-poster.redis-lock.simple-lock-key"
 
-	sequencerBatchPostMethodName                    = "addSequencerL2BatchFromOrigin0"
-	sequencerBatchPostWithBlobsMethodName           = "addSequencerL2BatchFromBlobs"
 	sequencerBatchPostDelayProofMethodName          = "addSequencerL2BatchFromOriginDelayProof"
 	sequencerBatchPostWithBlobsDelayProofMethodName = "addSequencerL2BatchFromBlobsDelayProof"
+	// oldSequencerBatchPostMethodName uses automatically generated solidity function
+	// binding with selector 8f111f3c for "addSequencerL2BatchFromOrigin1"
+	oldSequencerBatchPostMethodName          = "addSequencerL2BatchFromOrigin1"
+	newSequencerBatchPostMethodName          = "addSequencerL2BatchFromOrigin"
+	oldSequencerBatchPostWithBlobsMethodName = "addSequencerL2BatchFromBlobs"
+	newSequencerBatchPostWithBlobsMethodName = "addSequencerL2BatchFromBlobs0"
 )
 
 type batchPosterPosition struct {
 	MessageCount        arbutil.MessageIndex
 	DelayedMessageCount uint64
 	NextSeqNum          uint64
+	HotShotBlockNumber  uint64
 }
 
 type BatchPoster struct {
@@ -127,6 +139,16 @@ type BatchPoster struct {
 	parentChain  *parent.ParentChain
 	checkEip7623 bool
 	useEip7623   bool
+
+	espressoConfig             *EspressoConfig
+	bytesType                  abi.Type
+	bytes32ArrayType           abi.Type
+	blobsAttestationArguments  abi.Arguments
+	espressoStreamer           *espressostreamer.EspressoStreamer
+	espressoBatcherAddrMonitor BatcherAddrMonitorInterface
+	espressoRestarting         bool
+	signerAddr                 common.Address
+	fatalErrChan               chan error
 }
 
 type l1BlockBound int
@@ -211,7 +233,10 @@ func (c *BatchPosterConfig) Validate() error {
 	return nil
 }
 
+type EspressoConfigFetcher func() *EspressoConfig
 type BatchPosterConfigFetcher func() *BatchPosterConfig
+type EspressoBatchConfigFetcher func() *EspressoBatchPosterConfig
+type EspressoStreamerConfigFetcher func() *espressostreamer.EspressoStreamerConfig
 
 func DangerousBatchPosterConfigAddOptions(prefix string, f *pflag.FlagSet) {
 	f.Bool(prefix+".allow-posting-first-batch-when-sequencer-message-count-mismatch", DefaultBatchPosterConfig.Dangerous.AllowPostingFirstBatchWhenSequencerMessageCountMismatch, "allow posting the first batch even if sequence number doesn't match chain (useful after force-inclusion)")
@@ -321,6 +346,7 @@ var TestBatchPosterConfig = BatchPosterConfig{
 }
 
 type BatchPosterOpts struct {
+	ChainID       uint64
 	DataPosterDB  ethdb.Database
 	L1Reader      *headerreader.HeaderReader
 	Inbox         *InboxTracker
@@ -333,6 +359,11 @@ type BatchPosterOpts struct {
 	DAPWriter     daprovider.Writer
 	ParentChainID *big.Int
 	DAPReaders    *daprovider.ReaderRegistry
+
+	DataSigner signature.DataSignerFunc
+
+	EspressoConfigFetcher EspressoConfigFetcher
+	FatalErrChan          chan error
 }
 
 func NewBatchPoster(ctx context.Context, opts *BatchPosterOpts) (*BatchPoster, error) {
@@ -374,6 +405,25 @@ func NewBatchPoster(ctx context.Context, opts *BatchPosterOpts) (*BatchPoster, e
 	if err != nil {
 		return nil, err
 	}
+
+	// Espresso Config
+	var submitterOptions []submitter.EspressoSubmitterConfigOption
+	bytesType, err := abi.NewType("bytes", "", nil)
+	if err != nil {
+		return nil, err
+	}
+	bytes32ArrayType, err := abi.NewType("bytes32[]", "", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	method, ok := seqInboxABI.Methods[oldSequencerBatchPostWithBlobsMethodName]
+	if !ok {
+		return nil, errors.New("failed to find add batch method")
+	}
+	blobsAttestationArguments := method.Inputs
+	blobsAttestationArguments = append(blobsAttestationArguments, abi.Argument{Type: bytesType})
+
 	b := &BatchPoster{
 		l1Reader:           opts.L1Reader,
 		inbox:              opts.Inbox,
@@ -392,6 +442,13 @@ func NewBatchPoster(ctx context.Context, opts *BatchPosterOpts) (*BatchPoster, e
 		parentChain:        &parent.ParentChain{ChainID: opts.ParentChainID, L1Reader: opts.L1Reader},
 		checkEip7623:       checkEip7623,
 		useEip7623:         useEip7623,
+
+		espressoConfig:            opts.EspressoConfigFetcher(),
+		bytesType:                 bytesType,
+		bytes32ArrayType:          bytes32ArrayType,
+		blobsAttestationArguments: blobsAttestationArguments,
+		espressoRestarting:        true,
+		fatalErrChan:              opts.FatalErrChan,
 	}
 	b.messagesPerBatch, err = arbmath.NewMovingAverage[uint64](20)
 	if err != nil {
@@ -434,6 +491,161 @@ func NewBatchPoster(ctx context.Context, opts *BatchPosterOpts) (*BatchPoster, e
 			AfterDelayedMessagesRead: AfterDelayedMessagesRead,
 		})
 	}
+
+	submitterOptions = append(submitterOptions, WithTransactionStreamer(opts.Streamer))
+
+	hotshotUrl := opts.EspressoConfigFetcher().BatchPoster.HotShotUrl
+	// If the hotshot URL is non-empty, create the Espresso client.
+	if hotshotUrl != "" {
+		hotShotClient := hotshotClient.NewClient(hotshotUrl)
+		submitterOptions = append(submitterOptions, submitter.WithEspressoClient(hotShotClient))
+
+		// If hotshot url is set, also set the sequencer inbox
+		if seqInbox == nil {
+			log.Error("espresso mode enabled without a sequencer inbox address")
+			return nil, fmt.Errorf("espresso mode enabled without a sequencer inbox address")
+		}
+		bridgeAddress, err := seqInbox.Bridge(&bind.CallOpts{Context: context.Background()})
+		if err != nil {
+			return nil, fmt.Errorf("espresso mode enabled bridge")
+		}
+		bridge, err := bridgegen.NewBridge(bridgeAddress, opts.L1Reader.Client())
+		if err != nil {
+			return nil, fmt.Errorf("espresso mode enabled without bridge")
+		}
+
+		// check if the pos is already finalized on L1
+		// and get the current finalized block number from L1
+		blockNumber, err := opts.L1Reader.LatestFinalizedBlockNr(context.Background())
+		if err != nil {
+			return nil, fmt.Errorf("failed to get finalized block number: %w", err)
+		}
+
+		// Edge case: its possible that batch poster is started even before the `DeployedAt` block is finalized
+		// in that case we should use the `DeployedAt` block number because no message would have been posted before that
+		if blockNumber < opts.DeployInfo.DeployedAt {
+			blockNumber = opts.DeployInfo.DeployedAt
+		}
+
+		sequencerMessageCount, err := bridge.SequencerReportedSubMessageCount(&bind.CallOpts{
+			BlockNumber: new(big.Int).SetUint64(blockNumber),
+		})
+		if err != nil {
+			return nil, fmt.Errorf("failed to get sequencerMessageCount: %w", err)
+		}
+
+		submitterOptions = append(submitterOptions, submitter.WithInitialFinalizedSequencerMessageCount(sequencerMessageCount))
+
+		initStringAddresses := opts.EspressoConfigFetcher().BatchPoster.InitBatcherAddresses
+		// Convert the init addresses to common.Address
+		initAddresses := []common.Address{}
+		for _, addr := range initStringAddresses {
+			initAddresses = append(initAddresses, common.HexToAddress(addr))
+		}
+		if len(initAddresses) == 0 {
+			addr, err := recoverAddressFromSigner(opts.DataSigner)
+			if err != nil {
+				return nil, fmt.Errorf("failed to recover address from signer: %w", err)
+			}
+
+			initAddresses = []common.Address{addr}
+		}
+		addr, err := recoverAddressFromSigner(opts.DataSigner)
+		if err != nil {
+			return nil, err
+		}
+		b.signerAddr = addr
+
+		// We dont need auth reads here because batch poster is not reliant on the
+		// database for determining which messages to post, it gets the messages
+		// from Espresso directly
+		db, err := authdb.NewAuthDB(opts.DataPosterDB, nil, true)
+		if err != nil {
+			return nil, err
+		}
+		var monitor BatcherAddrMonitorInterface
+		if len(opts.EspressoConfigFetcher().BatchPoster.AddressValidRanges) == 0 {
+			monitor = NewBatcherAddrMonitor(
+				initAddresses,
+				&db,
+				opts.L1Reader,
+				opts.DeployInfo.SequencerInbox,
+				opts.DeployInfo.DeployedAt,
+				opts.EspressoConfigFetcher().Streamer.AddressMonitorStartL1,
+				opts.EspressoConfigFetcher().Streamer.AddressMonitorStep,
+			)
+		} else {
+			monitor = NewBatcherAddrSimpleMonitor(opts.EspressoConfigFetcher().BatchPoster.AddressValidRanges)
+		}
+
+		espressoStreamer := espressostreamer.NewEspressoStreamer(
+			opts.ChainID,
+			opts.EspressoConfigFetcher().Streamer.HotShotBlock,
+			nil,
+			hotShotClient,
+			false,
+			func(l1Height uint64, addr common.Address) (bool, error) {
+				return monitor.IsValid(ctx, addr, l1Height)
+			},
+			opts.EspressoConfigFetcher().Streamer.TxnsPollingInterval,
+		)
+
+		b.espressoBatcherAddrMonitor = monitor
+		b.espressoStreamer = espressoStreamer
+	}
+
+	if b.espressoStreamer != nil {
+		cfg := opts.EspressoConfigFetcher().BatchPoster
+
+		submitterOptions = append(
+			submitterOptions,
+			submitter.WithTxnsMonitoringInterval(cfg.TxnsMonitoringInterval),
+			submitter.WithTxnsResubmissionInterval(cfg.TxnsResubmissionInterval),
+			submitter.WithMaxTransactionSize(EspressoTxSizeLimit),
+			submitter.WithResubmitEspressoTxDeadline(cfg.ResubmitEspressoTxDeadline),
+			submitter.WithCanSubmit(func(ctx context.Context) (bool, error) {
+				return b.espressoStreamer.CanBatcherAddressSend(ctx, b.signerAddr)
+			}),
+		)
+
+		// Get the espressoTEEVerifier address for the sequencer inbox contract
+		espresssoTEEVerifierAddress, err := seqInbox.EspressoTEEVerifier(&bind.CallOpts{})
+		if err != nil {
+			return nil, err
+		}
+
+		verifier := espressotee.NewEspressoTEEVerifier(espresssoTEEVerifierAddress.Hex(), opts.L1Reader.Client(), espresssoTEEVerifierAddress)
+		teeType, err := espressotee.FromString(cfg.TeeType)
+		if err != nil {
+			return nil, fmt.Errorf("unsupported tee type in config: %s", cfg.TeeType)
+		}
+
+		if b.dataPoster.Auth() == nil {
+			panic("TransactOpts is nil")
+		}
+		batchPosterServiceType := espressotee.BatchPoster
+		if teeType == espressotee.TESTS {
+			batchPosterServiceType = espressotee.Test
+		}
+		submitterOptions = append(
+			submitterOptions,
+			// TODO: pass the persistent private key to the key manager in future
+			submitter.WithKeyManager(
+				espresso_key_manager.NewEspressoKeyManager(verifier, b.dataPoster, opts.DataSigner, teeType, batchPosterServiceType, nil, opts.EspressoConfigFetcher().BatchPoster.AttestationServiceURL, opts.EspressoConfigFetcher().BatchPoster.KeyPairAttestationsPath, opts.ChainID),
+			),
+		)
+
+		submitter, err := submitter.NewPollingEspressoSubmitter(
+			submitterOptions...,
+		)
+
+		if err != nil {
+			return nil, fmt.Errorf("failed to create espresso original submitter: %w", err)
+		}
+
+		opts.Streamer.espressoSubmitter = submitter
+	}
+
 	return b, nil
 }
 
@@ -972,6 +1184,7 @@ func (s *batchSegments) testForOverflow(isHeader bool) (bool, error) {
 			"current", s.totalUncompressedSize,
 			"max", arbstate.MaxDecompressedLen,
 			"isHeader", isHeader)
+		log.Debug("Adding to batch would cause overflow: s.totalUncompressedSize > arbstate.MaxDecompressedLen", "s.totalUncompressedSize", s.totalUncompressedSize, "arbstate.MaxDecompressedLen", arbstate.MaxDecompressedLen)
 		return true, nil
 	}
 	// we've reached the max number of segments
@@ -980,6 +1193,7 @@ func (s *batchSegments) testForOverflow(isHeader bool) (bool, error) {
 			"segments", len(s.rawSegments),
 			"max", arbstate.MaxSegmentsPerSequencerMessage,
 			"isHeader", isHeader)
+		log.Debug("Adding to batch would cause overflow: len(s.rawSegments) >= arbstate.MaxSegmentsPerSequencerMessage", "len(s.rawSegments)", len(s.rawSegments), "arbstate.MaxSegmentsPerSequencerMessage", arbstate.MaxSegmentsPerSequencerMessage)
 		return true, nil
 	}
 	// there is room, no need to flush
@@ -992,6 +1206,7 @@ func (s *batchSegments) testForOverflow(isHeader bool) (bool, error) {
 	}
 	err := s.compressedWriter.Flush()
 	if err != nil {
+		log.Debug("Adding to batch would cause overflow: Error in compressedWriter.Flush()")
 		return true, err
 	}
 	s.lastCompressedSize = s.compressedBuffer.Len()
@@ -1001,6 +1216,7 @@ func (s *batchSegments) testForOverflow(isHeader bool) (bool, error) {
 			"compressedSize", s.lastCompressedSize,
 			"limit", s.sizeLimit,
 			"isHeader", isHeader)
+		log.Debug("Adding to batch would cause overflow: s.lastCompressedSize >= s.sizeLimit", "s.lastCompressedSize", s.lastCompressedSize, "s.sizeLimit", s.sizeLimit)
 		return true, nil
 	}
 	return false, nil
@@ -1043,6 +1259,7 @@ func (s *batchSegments) addSegment(segment []byte, isHeader bool) (bool, error)
 		return false, err
 	}
 	if overflow {
+		log.Info("Batch is full and closed. Adding next message would cause an overflow.")
 		return false, s.close()
 	}
 	s.rawSegments = append(s.rawSegments, segment)
@@ -1143,6 +1360,251 @@ func (s *batchSegments) CloseAndGetBytes() ([]byte, error) {
 	return fullMsg, nil
 }
 
+func (b *BatchPoster) getCalldataForEspressoBatch(
+	seqNum *big.Int,
+	prevMsgNum arbutil.MessageIndex,
+	newMsgNum arbutil.MessageIndex,
+	l2MessageData []byte,
+	delayedMsg uint64,
+) ([]byte, error) {
+	method, ok := b.seqInboxABI.Methods[oldSequencerBatchPostMethodName]
+	if !ok {
+		return nil, errors.New("failed to find add batch method")
+	}
+
+	hotshotBlockNumber := new(big.Int).SetUint64(0)
+	// Remove this condition once we have get an espresso streamer
+	if b.espressoStreamer != nil {
+		earliestHotShot := b.espressoStreamer.GetCurrentEarliestHotShotBlockNumber(uint64(newMsgNum))
+		hotshotBlockNumber = hotshotBlockNumber.SetUint64(earliestHotShot)
+	}
+
+	uint256Type, err := abi.NewType("uint256", "", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create uint256 type: %w", err)
+	}
+
+	var arguments abi.Arguments
+	arguments = append(arguments, method.Inputs...)
+	arguments = append(arguments, abi.Argument{Type: uint256Type})
+
+	calldata, err := arguments.Pack(
+		seqNum,
+		l2MessageData,
+		new(big.Int).SetUint64(delayedMsg),
+		b.config().gasRefunder,
+		new(big.Int).SetUint64(uint64(prevMsgNum)),
+		new(big.Int).SetUint64(uint64(newMsgNum)),
+		hotshotBlockNumber,
+	)
+
+	// Later append the delay proof if needed for getting the attestion quote.
+	// If not, only append at the end of the calldata as done below.
+	if err != nil {
+		return nil, err
+	}
+
+	var signature []byte
+	teeType := espresso_key_manager.NITRO
+	if espressoSubmitter := b.streamer.espressoSubmitter; espressoSubmitter != nil {
+		keyManager := espressoSubmitter.GetKeyManager()
+		signature, err = keyManager.SignMessage(calldata)
+		if err != nil {
+			return nil, fmt.Errorf("failed to sign the calldata: %w", err)
+		}
+		teeType = keyManager.TeeType()
+	} else {
+		// Not running espresso mode. This should happen in testing only.
+		log.Error("BatchPoster is not running in espresso mode, no signature will be attached to the batch")
+
+		// Get the verifier address. It calls the contract every time and not that efficient but it's only for testing
+		// and we don't want to hardcode the address in case the contract changes.
+		espressoTEEVerifierAddress, err := b.seqInbox.EspressoTEEVerifier(&bind.CallOpts{})
+		if err != nil {
+			return nil, err
+		}
+		log.Info("signing messages with test private key")
+		signature, err = espresso_key_manager.SignTypedMessage(calldata, TestEspressoPrivateKey, b.parentChain.ChainID.Uint64(), espressoTEEVerifierAddress.Hex())
+		if err != nil {
+			return nil, fmt.Errorf("failed to sign the calldata with test private key: %w", err)
+		}
+	}
+
+	sigLength := len(signature)
+	if sigLength > 0 {
+		// Get the last byte (v)
+		vIndex := sigLength - 1
+		v := signature[vIndex]
+
+		// Adjusting ECDSA signature 'v' value for Ethereum compatibility
+		// Get `v` from the signature and verify the byte is in expected format for openzeppelin `ECDSA.recover`
+		// https://github.com/ethereum/go-ethereum/issues/19751
+		if v == 0 || v == 1 {
+			signature[vIndex] = v + 27
+		}
+	}
+
+	bytesType, err := abi.NewType("bytes", "", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create bytes type: %w", err)
+	}
+	uint8Type, err := abi.NewType("uint8", "", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create uint8 type: %w", err)
+	}
+
+	espressoMetadata, err := abi.Arguments{
+		{Type: uint256Type},
+		{Type: bytesType},
+		{Type: uint8Type},
+	}.Pack(hotshotBlockNumber, signature, teeType)
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to pack calldata with hotshot number and signature: %w", err)
+	}
+
+	method, ok = b.seqInboxABI.Methods[newSequencerBatchPostMethodName]
+	if !ok {
+		return nil, errors.New("failed to find add batch method")
+	}
+	calldata, err = method.Inputs.Pack(
+		seqNum,
+		l2MessageData,
+		new(big.Int).SetUint64(delayedMsg),
+		b.config().gasRefunder,
+		new(big.Int).SetUint64(uint64(prevMsgNum)),
+		new(big.Int).SetUint64(uint64(newMsgNum)),
+		espressoMetadata,
+	)
+
+	if err != nil {
+		return nil, err
+	}
+
+	fullCalldata := append([]byte{}, method.ID...)
+	fullCalldata = append(fullCalldata, calldata...)
+	return fullCalldata, nil
+}
+
+func (b *BatchPoster) getCalldataForEspressoBlobBatch(
+	seqNum *big.Int,
+	prevMsgNum arbutil.MessageIndex,
+	newMsgNum arbutil.MessageIndex,
+	l2MessageData []byte,
+	delayedMsg uint64,
+) ([]byte, error) {
+	method, ok := b.seqInboxABI.Methods[newSequencerBatchPostWithBlobsMethodName]
+	if !ok {
+		return nil, errors.New("failed to find add batch method")
+	}
+	kzgBlobs, err := blobs.EncodeBlobs(l2MessageData)
+	if err != nil {
+		return nil, err
+	}
+	_, blobHashes, err := blobs.ComputeCommitmentsAndHashes(kzgBlobs)
+	if err != nil {
+		return nil, err
+	}
+	// initially constructing the calldata using the old SequencerBatchPostWithBlobsMethodName method
+	// This will allow us to get the attestation quote on the hash of the dataPoster
+	encodedBlobs, err := abi.Arguments{abi.Argument{Type: b.bytes32ArrayType}}.Pack(blobHashes)
+
+	if err != nil {
+		return nil, err
+	}
+
+	hotshotBlockNumber := new(big.Int).SetUint64(0)
+	// Remove this condition once we have get an espresso streamer
+	if b.espressoStreamer != nil {
+		earliestHotShot := b.espressoStreamer.GetCurrentEarliestHotShotBlockNumber(uint64(newMsgNum))
+		hotshotBlockNumber = hotshotBlockNumber.SetUint64(earliestHotShot)
+	}
+
+	uint256Type, err := abi.NewType("uint256", "", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create uint256 type: %w", err)
+	}
+
+	var arguments abi.Arguments
+	arguments = append(arguments, method.Inputs...)
+	arguments = append(arguments, abi.Argument{Type: uint256Type})
+
+	calldata, err := arguments.Pack(
+		seqNum,
+		new(big.Int).SetUint64(delayedMsg),
+		b.config().gasRefunder,
+		new(big.Int).SetUint64(uint64(prevMsgNum)),
+		new(big.Int).SetUint64(uint64(newMsgNum)),
+		encodedBlobs,
+		hotshotBlockNumber,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	var signature []byte
+	teeType := espresso_key_manager.NITRO
+	if espressoSubmitter := b.streamer.espressoSubmitter; espressoSubmitter != nil {
+		keyManager := espressoSubmitter.GetKeyManager()
+		signature, err = keyManager.SignMessage(calldata)
+		if err != nil {
+			return nil, fmt.Errorf("failed to sign the calldata: %w", err)
+		}
+
+		sigLength := len(signature)
+		if sigLength > 0 {
+			// Get the last byte (v)
+			vIndex := sigLength - 1
+			v := signature[vIndex]
+
+			// Adjusting ECDSA signature 'v' value for Ethereum compatibility
+			// Get `v` from the signature and verify the byte is in expected format for openzeppelin `ECDSA.recover`
+			// https://github.com/ethereum/go-ethereum/issues/19751
+			if v == 0 || v == 1 {
+				signature[vIndex] = v + 27
+			}
+		}
+		teeType = keyManager.TeeType()
+	}
+
+	bytesType, err := abi.NewType("bytes", "", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create bytes type: %w", err)
+	}
+
+	uint8Type, err := abi.NewType("uint8", "", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create uint8 type: %w", err)
+	}
+
+	espressoMetadata, err := abi.Arguments{
+		{Type: uint256Type},
+		{Type: bytesType},
+		{Type: uint8Type},
+	}.Pack(hotshotBlockNumber, signature, teeType)
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to pack calldata with hotshot number and signature: %w", err)
+	}
+
+	calldata, err = method.Inputs.Pack(
+		seqNum,
+		new(big.Int).SetUint64(delayedMsg),
+		b.config().gasRefunder,
+		new(big.Int).SetUint64(uint64(prevMsgNum)),
+		new(big.Int).SetUint64(uint64(newMsgNum)),
+		espressoMetadata,
+	)
+
+	if err != nil {
+		return nil, err
+	}
+
+	fullCalldata := append([]byte{}, method.ID...)
+	fullCalldata = append(fullCalldata, calldata...)
+	return fullCalldata, nil
+}
+
 func (b *BatchPoster) encodeAddBatch(
 	seqNum *big.Int,
 	prevMsgNum arbutil.MessageIndex,
@@ -1157,12 +1619,12 @@ func (b *BatchPoster) encodeAddBatch(
 		if delayProof != nil {
 			methodName = sequencerBatchPostWithBlobsDelayProofMethodName
 		} else {
-			methodName = sequencerBatchPostWithBlobsMethodName
+			methodName = newSequencerBatchPostWithBlobsMethodName
 		}
 	} else if delayProof != nil {
 		methodName = sequencerBatchPostDelayProofMethodName
 	} else {
-		methodName = sequencerBatchPostMethodName
+		methodName = newSequencerBatchPostMethodName
 	}
 	method, ok := b.seqInboxABI.Methods[methodName]
 	if !ok {
@@ -1170,30 +1632,52 @@ func (b *BatchPoster) encodeAddBatch(
 	}
 	var args []any
 	var kzgBlobs []kzg4844.Blob
+	var fullCalldata []byte
 	var err error
-	args = append(args, seqNum)
-	if use4844 {
+	switch methodName {
+	case newSequencerBatchPostMethodName:
+		log.Info("Encoding Espresso validated batch via:", "method", methodName)
+		fullCalldata, err = b.getCalldataForEspressoBatch(seqNum, prevMsgNum, newMsgNum, l2MessageData, delayedMsg)
+		if err != nil {
+			return nil, nil, err
+		}
+	case newSequencerBatchPostWithBlobsMethodName:
+		log.Info("Encoding Espresso validated batch via testing:", "method", methodName)
 		kzgBlobs, err = blobs.EncodeBlobs(l2MessageData)
 		if err != nil {
 			return nil, nil, fmt.Errorf("failed to encode blobs: %w", err)
 		}
-	} else {
-		// EIP4844 transactions to the sequencer inbox will not use transaction calldata for L2 info.
-		args = append(args, l2MessageData)
-	}
-	args = append(args, new(big.Int).SetUint64(delayedMsg))
-	args = append(args, b.config().gasRefunder)
-	args = append(args, new(big.Int).SetUint64(uint64(prevMsgNum)))
-	args = append(args, new(big.Int).SetUint64(uint64(newMsgNum)))
-	if delayProof != nil {
-		args = append(args, delayProof)
-	}
-	calldata, err := method.Inputs.Pack(args...)
-	if err != nil {
-		return nil, nil, err
+		fullCalldata, err = b.getCalldataForEspressoBlobBatch(seqNum, prevMsgNum, newMsgNum, l2MessageData, delayedMsg)
+		if err != nil {
+			return nil, nil, err
+		}
+	default:
+		log.Info("Coming inside the oldSequencerBatchPostMethodName", "methodName", methodName)
+		args = append(args, seqNum)
+		if use4844 {
+			kzgBlobs, err = blobs.EncodeBlobs(l2MessageData)
+			if err != nil {
+				return nil, nil, fmt.Errorf("failed to encode blobs: %w", err)
+			}
+		} else {
+			// EIP4844 transactions to the sequencer inbox will not use transaction calldata for L2 info.
+			args = append(args, l2MessageData)
+		}
+		args = append(args, new(big.Int).SetUint64(delayedMsg))
+		args = append(args, b.config().gasRefunder)
+		args = append(args, new(big.Int).SetUint64(uint64(prevMsgNum)))
+		args = append(args, new(big.Int).SetUint64(uint64(newMsgNum)))
+		if delayProof != nil {
+			args = append(args, delayProof)
+		}
+		calldata, err := method.Inputs.Pack(args...)
+		if err != nil {
+			return nil, nil, err
+		}
+		fullCalldata = append([]byte{}, method.ID...)
+		fullCalldata = append(fullCalldata, calldata...)
+
 	}
-	fullCalldata := append([]byte{}, method.ID...)
-	fullCalldata = append(fullCalldata, calldata...)
 	return fullCalldata, kzgBlobs, nil
 }
 
@@ -1345,6 +1829,13 @@ func (b *BatchPoster) MaybePostSequencerBatch(ctx context.Context) (bool, error)
 	if b.batchReverted.Load() {
 		return false, fmt.Errorf("batch was reverted, not posting any more batches")
 	}
+	if espressoSubmitter := b.streamer.espressoSubmitter; espressoSubmitter != nil {
+		isRegistered, err := espressoSubmitter.GetKeyManager().CheckRegistration()
+		if !isRegistered {
+			return false, err
+		}
+	}
+
 	nonce, batchPositionBytes, err := b.dataPoster.GetNextNonceAndMeta(ctx)
 	if err != nil {
 		return false, err
@@ -1356,12 +1847,39 @@ func (b *BatchPoster) MaybePostSequencerBatch(ctx context.Context) (bool, error)
 
 	dbBatchCount, err := b.inbox.GetBatchCount()
 	if err != nil {
+		log.Error("Error getting batch count", "err", err)
 		return false, err
 	}
 	if dbBatchCount > batchPosition.NextSeqNum {
 		return false, fmt.Errorf("attempting to post batch %v, but the local inbox tracker database already has %v batches", batchPosition.NextSeqNum, dbBatchCount)
 	}
 	if b.building == nil || b.building.startMsgCount != batchPosition.MessageCount {
+		if b.espressoStreamer != nil {
+			b.espressoStreamer.AdvanceTo(uint64(batchPosition.MessageCount))
+			if b.espressoRestarting {
+				// Reset only once
+				log.Info("resetting streamer to parent chain", "messageCount", batchPosition.MessageCount)
+				// Fallback. For existing queued batches, we don't have the hotshot block number, so we reset to the parent chain.
+				b.resetStreamerToParentChainOrConfigHotshotBlock(batchPosition.MessageCount, ctx)
+				cnt, err := b.streamer.GetMessageCount()
+				if err != nil {
+					return false, err
+				}
+				// Submit transactions that were already in tx streamer
+				if cnt > batchPosition.MessageCount {
+					queue := []arbutil.MessageIndex{}
+					for i := batchPosition.MessageCount; i < cnt; i++ {
+						queue = append(queue, arbutil.MessageIndex(i))
+					}
+					err = b.streamer.espressoSubmitter.EnqueuePendingTransaction(queue)
+					if err != nil {
+						return false, err
+					}
+					log.Info("submitted pending transactions after restart", "from", batchPosition.MessageCount, "count", len(queue))
+				}
+				b.espressoRestarting = false
+			}
+		}
 		latestHeader, err := b.l1Reader.LastHeader(ctx)
 		if err != nil {
 			return false, err
@@ -1439,9 +1957,15 @@ func (b *BatchPoster) MaybePostSequencerBatch(ctx context.Context) (bool, error)
 			}
 		}
 	}
-	msgCount, err := b.streamer.GetMessageCount()
-	if err != nil {
-		return false, err
+	var msgCount arbutil.MessageIndex
+	if b.espressoStreamer == nil {
+		msgCount, err = b.streamer.GetMessageCount()
+		if err != nil {
+			log.Error("Error getting message count", "err", err)
+			return false, err
+		}
+	} else {
+		msgCount = arbutil.MessageIndex(b.espressoStreamer.GetMessageCount())
 	}
 	if msgCount <= batchPosition.MessageCount {
 		// There's nothing after the newest batch, therefore batch posting was not required
@@ -1519,10 +2043,44 @@ func (b *BatchPoster) MaybePostSequencerBatch(ctx context.Context) (bool, error)
 		}
 	}
 
+	var getNextMessage func() (*arbostypes.MessageWithMetadata, error)
+
+	if b.espressoStreamer == nil {
+		getNextMessage = func() (*arbostypes.MessageWithMetadata, error) {
+			msg, err := b.streamer.GetMessage(b.building.msgCount)
+			if err != nil {
+				return nil, err
+			}
+			return msg, nil
+		}
+	} else {
+		getNextMessage = func() (*arbostypes.MessageWithMetadata, error) {
+			espressoMsg := b.espressoStreamer.GetMsg(uint64(b.building.msgCount))
+			if espressoMsg == nil {
+				return nil, errors.New("the Espresso streamer has no more messages currently")
+			}
+			return &espressoMsg.MessageWithMeta, nil
+		}
+	}
+
+	if b.building.firstDelayedMsg != nil && b.espressoStreamer != nil {
+		// #nosec G115
+		timeSinceMsg := time.Since(time.Unix(int64(b.building.firstDelayedMsg.Message.Header.Timestamp), 0))
+		if timeSinceMsg >= config.MaxEmptyBatchDelay {
+			forcePostBatch = true
+			b.building.haveUsefulMessage = true
+		}
+		log.Info("reach max empty batch delay",
+			"firstDelayedMsgTimestamp", b.building.firstDelayedMsg.Message.Header.Timestamp,
+			"timeSinceMsg", timeSinceMsg,
+			"maxEmptyBatchDelay", config.MaxEmptyBatchDelay,
+		)
+	}
+
 	for b.building.msgCount < msgCount {
-		msg, err := b.streamer.GetMessage(b.building.msgCount)
+		msg, err := getNextMessage()
 		if err != nil {
-			log.Error("error getting message from streamer", "error", err)
+			log.Error("error getting next message", "err", err, "pos", b.building.msgCount)
 			break
 		}
 		if msg.Message.Header.BlockNumber < l1BoundMinBlockNumberWithBypass || msg.Message.Header.Timestamp < l1BoundMinTimestampWithBypass {
@@ -1793,10 +2351,15 @@ func (b *BatchPoster) MaybePostSequencerBatch(ctx context.Context) (bool, error)
 	if err != nil {
 		return false, err
 	}
+	var HotShotBlockNumber uint64
+	if b.espressoStreamer != nil {
+		HotShotBlockNumber = b.espressoStreamer.GetCurrentEarliestHotShotBlockNumber(uint64(b.building.msgCount))
+	}
 	newMeta, err := rlp.EncodeToBytes(batchPosterPosition{
 		MessageCount:        b.building.msgCount,
 		DelayedMessageCount: b.building.segments.delayedMsg,
 		NextSeqNum:          batchPosition.NextSeqNum + 1,
+		HotShotBlockNumber:  HotShotBlockNumber,
 	})
 	if err != nil {
 		return false, err
@@ -1959,6 +2522,18 @@ func (b *BatchPoster) Start(ctxIn context.Context) {
 	b.dataPoster.Start(ctxIn)
 	b.redisLock.Start(ctxIn)
 	b.StopWaiter.Start(ctxIn, b)
+	if b.espressoStreamer != nil {
+		err := b.espressoBatcherAddrMonitor.Start(ctxIn)
+		if err != nil {
+			log.Error("failed to start espresso batcher addr monitor", "err", err)
+			panic(err)
+		}
+		err = b.espressoStreamer.Start(ctxIn)
+		if err != nil {
+			log.Error("failed to start espresso streamer", "err", err)
+			panic(err)
+		}
+	}
 	b.LaunchThread(b.pollForReverts)
 	b.LaunchThread(b.pollForL1PriceData)
 	commonEphemeralErrorHandler := util.NewEphemeralErrorHandler(time.Minute, "", 0)
@@ -1967,6 +2542,7 @@ func (b *BatchPoster) Start(ctxIn context.Context) {
 	normalGasEstimationFailedEphemeralErrorHandler := util.NewEphemeralErrorHandler(5*time.Minute, ErrNormalGasEstimationFailed.Error(), time.Minute)
 	accumulatorNotFoundEphemeralErrorHandler := util.NewEphemeralErrorHandler(5*time.Minute, AccumulatorNotFoundErr.Error(), time.Minute)
 	nonceTooHighEphemeralErrorHandler := util.NewEphemeralErrorHandler(5*time.Minute, core.ErrNonceTooHigh.Error(), time.Minute)
+	espressoEphemeralErrorHandler := util.NewEphemeralErrorHandler(80*time.Minute, submitter.ErrEspressoValidation.Error(), time.Hour)
 	resetAllEphemeralErrs := func() {
 		commonEphemeralErrorHandler.Reset()
 		exceedMaxMempoolSizeEphemeralErrorHandler.Reset()
@@ -1974,7 +2550,9 @@ func (b *BatchPoster) Start(ctxIn context.Context) {
 		normalGasEstimationFailedEphemeralErrorHandler.Reset()
 		accumulatorNotFoundEphemeralErrorHandler.Reset()
 		nonceTooHighEphemeralErrorHandler.Reset()
+		espressoEphemeralErrorHandler.Reset()
 	}
+
 	b.CallIteratively(func(ctx context.Context) time.Duration {
 		var err error
 		if common.HexToAddress(b.config().GasRefunderAddress) != (common.Address{}) {
@@ -2014,11 +2592,22 @@ func (b *BatchPoster) Start(ctxIn context.Context) {
 				// Shutting down. No need to print the context canceled error.
 				return 0
 			}
+			if errors.Is(err, espresso_key_manager.FatalErrUnableToRegisterSigner) {
+				log.Warn(
+					"Espresso signer registration failed consecutively. Stopping.",
+					"retries", espressotee.EspressoMaxRetries,
+					"err", err,
+				)
+
+				b.fatalErrChan <- err
+			}
+
 			b.building = nil
 			logLevel := log.Error
 			// Likely the inbox tracker just isn't caught up.
 			// Let's see if this error disappears naturally.
 			logLevel = commonEphemeralErrorHandler.LogLevel(err, logLevel)
+			logLevel = espressoEphemeralErrorHandler.LogLevel(err, logLevel)
 			// If the error matches one of these, it's only logged at debug for the first minute,
 			// then at warn for the next 4 minutes, then at error. If the error isn't one of these,
 			// it'll be logged at warn for the first minute, then at error.
@@ -2045,6 +2634,9 @@ func (b *BatchPoster) StopAndWait() {
 	b.StopWaiter.StopAndWait()
 	b.dataPoster.StopAndWait()
 	b.redisLock.StopAndWait()
+	if b.espressoStreamer != nil {
+		b.espressoStreamer.StopAndWait()
+	}
 }
 
 type BoolRing struct {
diff --git a/arbnode/dataposter/data_poster.go b/arbnode/dataposter/data_poster.go
index ac2aee91bd7..896a13dd430 100644
--- a/arbnode/dataposter/data_poster.go
+++ b/arbnode/dataposter/data_poster.go
@@ -360,6 +360,14 @@ func (p *DataPoster) Sender() common.Address {
 	return p.auth.From
 }
 
+func (p *DataPoster) BaseFee() (*big.Int, error) {
+	header, err := p.headerReader.LastHeader(context.Background())
+	if err != nil {
+		return nil, err
+	}
+	return header.BaseFee, nil
+}
+
 func (p *DataPoster) MaxMempoolTransactions() uint64 {
 	if p.usingNoOpStorage {
 		return 1
@@ -502,7 +510,7 @@ func (p *DataPoster) GetNextNonceAndMeta(ctx context.Context) (uint64, []byte, e
 	if err != nil {
 		return 0, nil, err
 	}
-	if !hasMeta {
+	if !hasMeta || meta == nil || len(meta) == 0 {
 		meta, err = p.metadataRetriever(ctx, p.lastBlock)
 	}
 	return nonce, meta, err
@@ -555,6 +563,11 @@ func (p *DataPoster) feeAndTipCaps(ctx context.Context, nonce uint64, gasLimit u
 	if latestHeader.BaseFee == nil {
 		return nil, nil, nil, fmt.Errorf("latest parent chain block %v missing BaseFee (either the parent chain does not have EIP-1559 or the parent chain node is not synced)", latestHeader.Number)
 	}
+	log.Info("Base fee", "baseFee", latestHeader.BaseFee, "maxBaseFee", (big.NewInt(int64(config.MaxBaseFee))))
+
+	if (*latestHeader.BaseFee).Cmp(big.NewInt(int64(config.MaxBaseFee))) > 0 {
+		return nil, nil, nil, fmt.Errorf("latest parent chain block %v BaseFee %v is greater than max base fee %v", latestHeader.Number, latestHeader.BaseFee, config.MaxBaseFee)
+	}
 	currentBlobFee := big.NewInt(0)
 	if numBlobs > 0 {
 		if latestHeader.ExcessBlobGas != nil && latestHeader.BlobGasUsed != nil {
@@ -1335,6 +1348,7 @@ type DataPosterConfig struct {
 	Dangerous              DangerousConfig   `koanf:"dangerous"`
 	ExternalSigner         ExternalSignerCfg `koanf:"external-signer"`
 	MaxFeeCapFormula       string            `koanf:"max-fee-cap-formula" reload:"hot"`
+	MaxBaseFee             int64             `koanf:"max-base-fee" reload:"hot"`
 	ElapsedTimeBase        time.Duration     `koanf:"elapsed-time-base" reload:"hot"`
 	ElapsedTimeImportance  float64           `koanf:"elapsed-time-importance" reload:"hot"`
 	// When set, dataposter will not post new batches, but will keep running to
@@ -1412,6 +1426,8 @@ const (
 	// Note: The enable flag (post-4844-blobs) is NOT exposed here because batch poster
 	// controls that at its own configuration level.
 	DataPosterUsageBatchPoster
+
+	DataPosterUsageCaffNode
 )
 
 func DataPosterConfigAddOptions(prefix string, f *pflag.FlagSet, defaultDataPosterConfig DataPosterConfig, usageContext DataPosterUsageContext) {
@@ -1435,6 +1451,7 @@ func DataPosterConfigAddOptions(prefix string, f *pflag.FlagSet, defaultDataPost
 		"Currently available variables to construct the formula are BacklogOfBatches, UrgencyGWei, ElapsedTime, ElapsedTimeBase, ElapsedTimeImportance, and TargetPriceGWei")
 	f.Duration(prefix+".elapsed-time-base", defaultDataPosterConfig.ElapsedTimeBase, "unit to measure the time elapsed since creation of transaction used for maximum fee cap calculation")
 	f.Float64(prefix+".elapsed-time-importance", defaultDataPosterConfig.ElapsedTimeImportance, "weight given to the units of time elapsed used for maximum fee cap calculation")
+	f.Int64(prefix+".max-base-fee", defaultDataPosterConfig.MaxBaseFee, "maximum base fee")
 
 	signature.SimpleHmacConfigAddOptions(prefix+".redis-signer", f)
 	addDangerousOptions(prefix+".dangerous", f)
@@ -1488,6 +1505,7 @@ var DefaultDataPosterConfig = DataPosterConfig{
 	Dangerous:              DangerousConfig{ClearDBStorage: false},
 	ExternalSigner:         ExternalSignerCfg{Method: "eth_signTransaction", InsecureSkipVerify: false},
 	MaxFeeCapFormula:       "((BacklogOfBatches * UrgencyGWei) ** 2) + ((ElapsedTime/ElapsedTimeBase) ** 2) * ElapsedTimeImportance + TargetPriceGWei",
+	MaxBaseFee:             5000000000,
 	ElapsedTimeBase:        10 * time.Minute,
 	ElapsedTimeImportance:  10,
 	DisableNewTx:           false,
@@ -1527,6 +1545,7 @@ var TestDataPosterConfig = DataPosterConfig{
 	LegacyStorageEncoding:  false,
 	ExternalSigner:         ExternalSignerCfg{Method: "eth_signTransaction", InsecureSkipVerify: true},
 	MaxFeeCapFormula:       "((BacklogOfBatches * UrgencyGWei) ** 2) + ((ElapsedTime/ElapsedTimeBase) ** 2) * ElapsedTimeImportance + TargetPriceGWei",
+	MaxBaseFee:             5000000000,
 	ElapsedTimeBase:        10 * time.Minute,
 	ElapsedTimeImportance:  10,
 	DisableNewTx:           false,
diff --git a/arbnode/dataposter/dataposter_test.go b/arbnode/dataposter/dataposter_test.go
index ea2db124698..16f2faacf26 100644
--- a/arbnode/dataposter/dataposter_test.go
+++ b/arbnode/dataposter/dataposter_test.go
@@ -189,6 +189,8 @@ func TestFeeAndTipCaps_EnoughBalance_NoBacklog_NoUnconfirmed_BlobTx(t *testing.T
 			ElapsedTimeBase:       10 * time.Minute,
 			ElapsedTimeImportance: 10,
 			TargetPriceGwei:       60.,
+
+			MaxBaseFee: 1000000000 * 5,
 		}
 	}
 	expression, err := govaluate.NewEvaluableExpression(DefaultDataPosterConfig.MaxFeeCapFormula)
@@ -325,6 +327,8 @@ func TestFeeAndTipCaps_RBF_RisingBlobFee_FallingBaseFee(t *testing.T) {
 			ElapsedTimeBase:       10 * time.Minute,
 			ElapsedTimeImportance: 10,
 			TargetPriceGwei:       60.,
+
+			MaxBaseFee: 1000000000 * 5,
 		}
 	}
 	expression, err := govaluate.NewEvaluableExpression(DefaultDataPosterConfig.MaxFeeCapFormula)
diff --git a/arbnode/dataposter/storage/storage.go b/arbnode/dataposter/storage/storage.go
index df83f021244..6c88acaf587 100644
--- a/arbnode/dataposter/storage/storage.go
+++ b/arbnode/dataposter/storage/storage.go
@@ -22,6 +22,7 @@ var (
 	BlockValidatorPrefix string = "v" // the prefix for all block validator keys
 	StakerPrefix         string = "S" // the prefix for all staker keys
 	BatchPosterPrefix    string = "b" // the prefix for all batch poster keys
+	CaffNodePrefix       string = "c" // the prefix for all caffnode keys
 	// TODO(anodar): move everything else from schema.go file to here once
 	// execution split is complete.
 )
diff --git a/arbnode/espresso_batch_poster_config.go b/arbnode/espresso_batch_poster_config.go
new file mode 100644
index 00000000000..4275bc1d8e1
--- /dev/null
+++ b/arbnode/espresso_batch_poster_config.go
@@ -0,0 +1,64 @@
+package arbnode
+
+import (
+	"time"
+
+	"github.com/spf13/pflag"
+)
+
+// EspressoTxSizeLimit is 1 MB, to have some buffer we set it to 900 KB
+const EspressoTxSizeLimit int64 = 900 * 1024
+
+type EspressoBatchPosterConfig struct {
+	TeeType                    string        `koanf:"tee-type"`
+	HotShotUrl                 string        `koanf:"hotshot-url"`
+	TxnsMonitoringInterval     time.Duration `koanf:"txns-monitoring-interval"`
+	TxnsResubmissionInterval   time.Duration `koanf:"txns-resubmission-interval"`
+	ResubmitEspressoTxDeadline time.Duration `koanf:"resubmit-espresso-tx-deadline"`
+	AttestationServiceURL      string        `koanf:"attestation-service-url"`
+	KeyPairAttestationsPath    string        `koanf:"key-pair-attestations-path"`
+
+	EventPollingStep         uint64 `koanf:"event-polling-step"`
+	HotShotFirstPostingBlock uint64 `koanf:"hotshot-first-posting-block"`
+	// Please make sure that these addresses are already valid at the `AddressMonitorStartL1`
+	InitBatcherAddresses []string `koanf:"init-batcher-addresses"`
+
+	AddressValidRanges []AddressValidRangeConfig `koanf:"address-valid-ranges"`
+}
+
+func EspressoBatchPosterConfigAddOptions(prefix string, f *pflag.FlagSet) {
+	f.String(prefix+".tee-type", DefaultEspressoBatchPosterConfig.TeeType, "the Trusted Execution Environment (TEE) that Batch poster is running in")
+	f.String(prefix+".hotshot-url", DefaultEspressoBatchPosterConfig.HotShotUrl, "specifies the hotshot url if we are batching in espresso mode")
+	f.Uint64(prefix+".hotshot-first-posting-block", DefaultEspressoBatchPosterConfig.HotShotFirstPostingBlock, "specifies the l1 block number when this rollup started posting to hotshot")
+	f.Uint64(prefix+".event-polling-step", DefaultEspressoBatchPosterConfig.EventPollingStep, "specifies the number of blocks at a time to query when searching for logs emitted by batch posting.")
+	f.Duration(prefix+".txns-resubmission-interval", DefaultEspressoBatchPosterConfig.TxnsResubmissionInterval, "interval between checking if the node should resubmitting transactions to Espresso Network")
+	f.Duration(prefix+".resubmit-espresso-tx-deadline", DefaultEspressoBatchPosterConfig.ResubmitEspressoTxDeadline, "time threshold after which a transaction will be automatically resubmitted if no response is received")
+	f.Duration(prefix+".txns-monitoring-interval", DefaultEspressoBatchPosterConfig.TxnsMonitoringInterval, "time threshold after which a transaction will be automatically resubmitted if no response is received")
+	f.String(prefix+".attestation-service-url", DefaultEspressoBatchPosterConfig.AttestationServiceURL, "URL of the attestation service to use for obtaining zk proof over  attestation")
+	f.String(prefix+".key-pair-attestations-path", DefaultEspressoBatchPosterConfig.KeyPairAttestationsPath, "path to attestation documents with KMSKeyID, EncryptedPrivateKey attestations")
+	f.StringSlice(prefix+".init-batcher-addresses", DefaultEspressoBatchPosterConfig.InitBatcherAddresses, "specifies the init batcher addresses")
+}
+
+var DefaultEspressoBatchPosterConfig = EspressoBatchPosterConfig{
+	TxnsMonitoringInterval:     125 * time.Millisecond,
+	TxnsResubmissionInterval:   2 * time.Second,
+	ResubmitEspressoTxDeadline: 10 * time.Minute,
+	HotShotUrl:                 "",
+	TeeType:                    "NITRO",
+	AttestationServiceURL:      "",
+	HotShotFirstPostingBlock:   1,
+	InitBatcherAddresses:       []string{},
+	EventPollingStep:           100,
+	AddressValidRanges:         []AddressValidRangeConfig{},
+}
+
+var TestEspressoBatchPosterConfig = EspressoBatchPosterConfig{
+	TxnsMonitoringInterval: 2 * time.Second,
+	HotShotUrl:             "",
+	TeeType:                "TESTS",
+
+	HotShotFirstPostingBlock: 1,
+	InitBatcherAddresses:     []string{},
+	EventPollingStep:         100,
+	AddressValidRanges:       []AddressValidRangeConfig{},
+}
diff --git a/arbnode/espresso_batch_poster_helpers.go b/arbnode/espresso_batch_poster_helpers.go
new file mode 100644
index 00000000000..00b64223ed1
--- /dev/null
+++ b/arbnode/espresso_batch_poster_helpers.go
@@ -0,0 +1,73 @@
+package arbnode
+
+import (
+	"context"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/offchainlabs/nitro/arbutil"
+)
+
+// Reads state from external sources and resets the espresso streamer to start producing
+// messages from hotshot based on the source of truth on the parent chain
+func (b *BatchPoster) resetStreamerToParentChainOrConfigHotshotBlock(messageCount arbutil.MessageIndex, ctx context.Context) {
+	hotshotBlock := b.fetchHotshotBlockFromLastCheckpoint(ctx)
+	if hotshotBlock == 0 {
+		// if there hasn't been a batch posted, or we encountered an error, start reading from the configured hotshot block number.
+		hotshotBlock = b.espressoConfig.Streamer.HotShotBlock
+	}
+	b.espressoStreamer.Reset(uint64(messageCount), hotshotBlock)
+}
+
+// fetchHotshotBlockFromLastCheckpoint:
+// This function uses the sequencer inbox bridgegen contract to filter for logs related to the TEESignatureVerified events
+// If any of these events are encountered, it checks the log iterator for the data about this event.
+// Return:
+// returns the Hotshot height of the last event in the iterator returned from FilterTEESignatureVerified()
+// representing the most recently emitted hotshotblock height. Any errors encountered will result in 0 being returned.
+func (b *BatchPoster) fetchHotshotBlockFromLastCheckpoint(ctx context.Context) uint64 {
+	pollingStep := b.espressoConfig.BatchPoster.EventPollingStep
+	header, err := b.l1Reader.LastHeader(ctx)
+	if err != nil {
+		log.Error("Failed to fetch last header from parent chain", "err", err)
+		return 0
+	}
+
+	var lastHotshotHeight uint64 = 0
+	// Prevent unsigned integer underflow: in Go, subtracting a larger value
+	// from a smaller uint64 will wrap around to a very large number.
+	for i := header.Number.Uint64(); i >= b.espressoConfig.BatchPoster.HotShotFirstPostingBlock; i -= min(i, pollingStep) {
+		start := i - min(i, pollingStep)
+		if start < b.espressoConfig.BatchPoster.HotShotFirstPostingBlock {
+			start = b.espressoConfig.BatchPoster.HotShotFirstPostingBlock
+		}
+		filterOpts := bind.FilterOpts{
+			Start:   start,
+			End:     &i,
+			Context: ctx,
+		}
+
+		logIterator, err := b.seqInbox.FilterTEESignatureVerified(&filterOpts, []*big.Int{}, []*big.Int{})
+		if err != nil {
+			log.Error("Failed to obtain iterator for logs for block", "blockNumber", i, "err", err)
+			continue
+		}
+
+		if logIterator == nil {
+			continue
+		}
+
+		for logIterator.Next() {
+			lastHotshotHeight = logIterator.Event.HotshotHeight.Uint64()
+		}
+
+		if lastHotshotHeight > 0 {
+			return lastHotshotHeight
+		}
+	}
+
+	log.Warn("No logs found for Hotshot block")
+	return 0
+}
diff --git a/arbnode/espresso_batcher_addr_monitor.go b/arbnode/espresso_batcher_addr_monitor.go
new file mode 100644
index 00000000000..e5c4bda07fb
--- /dev/null
+++ b/arbnode/espresso_batcher_addr_monitor.go
@@ -0,0 +1,392 @@
+package arbnode
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/ethereum/go-ethereum/rpc"
+
+	"github.com/offchainlabs/nitro/espresso/authdb"
+	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
+	"github.com/offchainlabs/nitro/util/headerreader"
+	"github.com/offchainlabs/nitro/util/stopwaiter"
+)
+
+var ownerFunctionCalledID common.Hash
+
+// 13 minutes worth of blocks on L1 (assuming 12s block time)
+const BUFFER_WINDOW = 64
+
+func init() {
+	parsedSeqInboxABI, err := bridgegen.SequencerInboxMetaData.GetAbi()
+	if err != nil {
+		panic(err)
+	}
+	ownerFunctionCalledID = parsedSeqInboxABI.Events["OwnerFunctionCalled"].ID
+}
+
+type BatcherAddrMonitorInterface interface {
+	Start(ctx context.Context) error
+	IsValid(ctx context.Context, batcherAddress common.Address, l1Height uint64) (bool, error)
+}
+
+type BatcherAddrMonitor struct {
+	stopwaiter.StopWaiter
+	// This is corresponding L1 height to the parent height.
+	// If the parent chain is Ethereum, this is equal to the parent height.
+	lastProcessedL1Height     uint64
+	lastProcessedParentHeight uint64
+
+	// L1 heights where batcher addresses were updated
+	// This is append-only and sorted in ascending order
+	eventUpdatesAt []uint64
+	// validityCaches[0]: batcher addresses valid from eventUpdatesAt[0] to eventUpdatesAt[1]
+	// validityCaches[i]: batcher addresses valid from eventUpdatesAt[i] to eventUpdatesAt[i+1]
+	// validityCaches[last]: batcher addresses valid from eventUpdatesAt[last] to current height (inclusive)
+	// Cache all the validityCaches to avoid repeated lookups. Since the batcher addresses are relatively stable,
+	// this caching significantly improves performance for repeated validity checks.
+	validityCaches []map[common.Address]bool
+	// A batcher address becomes valid or invalid after it is included in a block that is finalized + bufferWindow old
+	// This makes sure our fast finality won't be hurt by L1 lag.
+	// This value should be part of consensus among all the caff nodes and batchers.
+	// It is not configurable and we currently hardcode it first.
+	bufferWindow uint64
+	db           *authdb.AuthDB
+	needsPersist bool
+	// Init addresses are the addresses serve as fallback valid addresses
+	initAddresses   []common.Address
+	fromParentBlock uint64
+
+	l1Reader *headerreader.HeaderReader
+
+	seqInboxAddr      common.Address
+	seqInboxInterface *bridgegen.SequencerInbox
+	deployAt          uint64
+	step              uint64
+}
+
+func NewBatcherAddrMonitor(
+	initAddresses []common.Address,
+	db *authdb.AuthDB,
+	l1Reader *headerreader.HeaderReader,
+	seqInboxAddr common.Address,
+	deployAt uint64,
+	fromParentBlock uint64,
+	step uint64,
+) *BatcherAddrMonitor {
+	var seqInboxInterface *bridgegen.SequencerInbox
+	if l1Reader != nil {
+		var err error
+		seqInboxInterface, err = bridgegen.NewSequencerInbox(seqInboxAddr, l1Reader.Client())
+		if err != nil {
+			panic(err)
+		}
+	}
+	if fromParentBlock < deployAt+1 {
+		fromParentBlock = deployAt + 1
+	}
+	return &BatcherAddrMonitor{
+		initAddresses:             initAddresses,
+		db:                        db,
+		l1Reader:                  l1Reader,
+		seqInboxAddr:              seqInboxAddr,
+		seqInboxInterface:         seqInboxInterface,
+		deployAt:                  deployAt,
+		lastProcessedParentHeight: fromParentBlock - 1,
+		fromParentBlock:           fromParentBlock,
+		step:                      step,
+		bufferWindow:              BUFFER_WINDOW,
+	}
+}
+
+func (b *BatcherAddrMonitor) IsValid(ctx context.Context, batcherAddress common.Address, l1Height uint64) (bool, error) {
+	if len(b.eventUpdatesAt) == 0 {
+		b.addEventUpdates([]uint64{b.fromParentBlock})
+		for _, addr := range b.initAddresses {
+			b.validityCaches[0][addr] = true
+		}
+	}
+	height := b.fromParentBlock - 1
+	if l1Height > b.bufferWindow {
+		height = l1Height - b.bufferWindow
+	}
+	if height > b.lastProcessedL1Height {
+		return false, fmt.Errorf("batcher address monitor is lagging behind, height: %d", l1Height)
+	}
+
+	index := 0
+	for i, updateHeight := range b.eventUpdatesAt {
+		if updateHeight > height {
+			break
+		}
+		index = i
+	}
+
+	cache := b.validityCaches[index]
+	if valid, exists := cache[batcherAddress]; exists {
+		return valid, nil
+	}
+
+	isBatcher, err := b.seqInboxInterface.IsBatchPoster(&bind.CallOpts{}, batcherAddress)
+	if err != nil {
+		return false, err
+	}
+	log.Debug("Batcher address validation", "address", batcherAddress, "isBatcher", isBatcher, "l1Height", l1Height)
+	cache[batcherAddress] = isBatcher
+	b.needsPersist = true
+
+	return isBatcher, nil
+}
+
+func (b *BatcherAddrMonitor) SetParentHeight(height uint64) {
+	b.lastProcessedParentHeight = height
+}
+
+func (b *BatcherAddrMonitor) SetL1Height(height uint64) {
+	b.lastProcessedL1Height = height
+}
+
+func (b *BatcherAddrMonitor) GetLastProcessedParentHeight() uint64 {
+	return b.lastProcessedParentHeight
+}
+
+func (b *BatcherAddrMonitor) LookupAddressUpdates(ctx context.Context, fromBlock, toBlock uint64) ([]uint64, error) {
+	from := big.NewInt(0).SetUint64(fromBlock)
+	to := big.NewInt(0).SetUint64(toBlock)
+	query := ethereum.FilterQuery{
+		BlockHash: nil,
+		FromBlock: from,
+		ToBlock:   to,
+		Addresses: []common.Address{b.seqInboxAddr},
+		Topics: [][]common.Hash{
+			{ownerFunctionCalledID},
+			{common.BigToHash(big.NewInt(1))},
+		},
+	}
+	logs, err := b.l1Reader.Client().FilterLogs(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	var result []uint64
+	for _, log := range logs {
+		l1Height := log.BlockNumber
+		if b.l1Reader.IsParentChainArbitrum() {
+			header, err := b.l1Reader.Client().HeaderByNumber(ctx, big.NewInt(0).SetUint64(log.BlockNumber))
+			if err != nil {
+				return nil, err
+			}
+			l1Height = types.DeserializeHeaderExtraInformation(header).L1BlockNumber
+		}
+		result = append(result, l1Height)
+	}
+	return result, nil
+}
+
+func (b *BatcherAddrMonitor) Store() error {
+
+	newBatch := b.db.NewBatch()
+
+	err := authdb.WriteAddresses(newBatch, b.validityCaches)
+	if err != nil {
+		return fmt.Errorf("failed to write addresses: %w", err)
+	}
+
+	eventsBytes, err := rlp.EncodeToBytes(b.eventUpdatesAt)
+	if err != nil {
+		return fmt.Errorf("failed to encode events: %w", err)
+	}
+	err = authdb.WriteEvents(newBatch, eventsBytes)
+	if err != nil {
+		return fmt.Errorf("failed to write events: %w", err)
+	}
+
+	err = authdb.WriteLastProcessedHeight(newBatch, b.lastProcessedParentHeight)
+	if err != nil {
+		return fmt.Errorf("failed to put last processed height: %w", err)
+	}
+
+	return newBatch.Write()
+}
+
+func (b *BatcherAddrMonitor) Restore() error {
+	lastProcessedHeight, err := authdb.ReadLastProcessedHeight(b.db)
+	if err != nil {
+		return fmt.Errorf("failed to get last processed height: %w", err)
+	}
+
+	if lastProcessedHeight < b.fromParentBlock {
+		// It is running with a higher parent block than last processed height,
+		// prvious result becomes invalid
+		return nil
+	}
+	updates, err := authdb.ReadEvents(b.db)
+	if err != nil {
+		return fmt.Errorf("failed to get events: %w", err)
+	}
+
+	// Parse the RLP-encoded events into []uint64
+	var eventUpdates []uint64
+	if len(updates) > 0 {
+		if err := rlp.DecodeBytes(updates, &eventUpdates); err != nil {
+			return fmt.Errorf("failed to decode events: %w", err)
+		}
+	}
+	b.eventUpdatesAt = eventUpdates
+
+	b.lastProcessedParentHeight = lastProcessedHeight
+
+	addresses, err := authdb.ReadAddresses(b.db)
+	if err != nil {
+		return fmt.Errorf("failed to get addresses: %w", err)
+	}
+	b.validityCaches = addresses
+
+	return nil
+}
+
+func (b *BatcherAddrMonitor) backfill(ctx context.Context) error {
+	latestParentHeader, err := b.l1Reader.Client().HeaderByNumber(ctx, new(big.Int).SetInt64(int64(rpc.FinalizedBlockNumber)))
+	if err != nil {
+		return fmt.Errorf("failed to get latest parent height: %w", err)
+	}
+	lastProcessedHeight := b.GetLastProcessedParentHeight()
+
+	blocksToRead := b.step
+	allowedRetry := 10
+	retry := 0
+	latestParentHeight := latestParentHeader.Number.Uint64()
+	log.Info("batcher addr monitor backfilling")
+	for retry < allowedRetry {
+		if lastProcessedHeight >= latestParentHeight {
+			// Already backfilled to the current known latest height.
+			// However, the latest height might actually be a bit behind,
+			// so update it to match lastProcessedHeight before exiting.
+			latestParentHeight = lastProcessedHeight
+			break
+		}
+
+		log.Info("batcher addr monitor backfilling", "lastProcessedHeight", lastProcessedHeight, "latestParentHeight", latestParentHeight, "blocksToRead", blocksToRead)
+		updates, err := b.LookupAddressUpdates(ctx, lastProcessedHeight+1, lastProcessedHeight+blocksToRead)
+		if err != nil {
+			retry++
+			log.Error("failed to lookup events", "err", err)
+			continue
+		}
+		if len(updates) > 0 {
+			b.addEventUpdates(updates)
+		}
+		lastProcessedHeight += blocksToRead
+		latestParentHeader, err = b.l1Reader.Client().HeaderByNumber(ctx, new(big.Int).SetInt64(int64(rpc.FinalizedBlockNumber)))
+		if err != nil {
+			retry++
+			log.Error("failed to get latest parent height", "err", err)
+			continue
+		}
+		latestParentHeight = latestParentHeader.Number.Uint64()
+	}
+	b.lastProcessedParentHeight = latestParentHeight
+	b.lastProcessedL1Height = latestParentHeight
+	if b.l1Reader.IsParentChainArbitrum() {
+		b.lastProcessedL1Height = types.DeserializeHeaderExtraInformation(latestParentHeader).L1BlockNumber
+	}
+	log.Info("batcher addr monitor backfilled", "parentHeight", b.lastProcessedParentHeight, "l1Height", b.lastProcessedL1Height)
+
+	return nil
+}
+
+func (b *BatcherAddrMonitor) Process(ctx context.Context) error {
+	latestHeader, err := b.l1Reader.LatestFinalizedBlockHeader(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to get latest finalized block header: %w", err)
+	}
+	latestBlockNumber := latestHeader.Number.Uint64()
+	parentHeight := b.GetLastProcessedParentHeight()
+	// The latest finalized block doesn't change
+	if parentHeight >= latestBlockNumber {
+		log.Debug("processing", "parentHeight", parentHeight, "latestBlockNumber", latestBlockNumber)
+		return nil
+	}
+
+	newHeight := latestBlockNumber
+	updates, err := b.LookupAddressUpdates(ctx, parentHeight+1, newHeight)
+	log.Debug("looking up events", "from", parentHeight+1, "to", newHeight)
+	if err != nil {
+		return err
+	}
+	b.addEventUpdates(updates)
+	l1Height := newHeight
+	if b.l1Reader.IsParentChainArbitrum() {
+		l1Height = types.DeserializeHeaderExtraInformation(latestHeader).L1BlockNumber
+	}
+	b.SetL1Height(l1Height)
+	b.SetParentHeight(newHeight)
+	if len(updates) == 0 {
+		// If no events are found, we still need to update the last processed height
+		batch := b.db.NewBatch()
+		err = authdb.WriteLastProcessedHeight(batch, newHeight)
+		if err != nil {
+			return fmt.Errorf("failed to store last processed height: %w", err)
+		}
+		return batch.Write()
+	} else if b.needsPersist {
+		err := b.Store()
+		if err != nil {
+			return fmt.Errorf("failed to store in batcher address monitor: %w", err)
+		}
+		b.needsPersist = false
+	}
+	return nil
+}
+
+func (b *BatcherAddrMonitor) addEventUpdates(updates []uint64) {
+	b.eventUpdatesAt = append(b.eventUpdatesAt, updates...)
+	for i := 0; i < len(updates); i++ {
+		b.validityCaches = append(b.validityCaches, make(map[common.Address]bool))
+	}
+}
+
+func (b *BatcherAddrMonitor) Start(ctx context.Context) error {
+	log.Info("starting the batch poster address monitor")
+	b.StopWaiter.Start(ctx, b)
+
+	err := b.Restore()
+	if err != nil && !rawdb.IsDbErrNotFound(err) {
+		return fmt.Errorf("failed to restore batcher address monitor: %w", err)
+	}
+
+	err = b.backfill(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to backfill batcher address monitor: %w", err)
+	}
+
+	headerchan, unsubscribe := b.l1Reader.Subscribe(false)
+
+	b.LaunchThread(func(ctx context.Context) {
+		for {
+			select {
+			case <-ctx.Done():
+				unsubscribe()
+				return
+			case <-headerchan:
+				err := b.Process(ctx)
+				if err != nil {
+					continue
+				}
+			}
+		}
+	})
+
+	return nil
+}
+
+func (b *BatcherAddrMonitor) StopAndWait() {
+	b.StopWaiter.StopAndWait()
+}
diff --git a/arbnode/espresso_batcher_addr_monitor_test.go b/arbnode/espresso_batcher_addr_monitor_test.go
new file mode 100644
index 00000000000..6d8c8589650
--- /dev/null
+++ b/arbnode/espresso_batcher_addr_monitor_test.go
@@ -0,0 +1,113 @@
+package arbnode
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/ethclient"
+
+	"github.com/offchainlabs/nitro/espresso/authdb"
+	"github.com/offchainlabs/nitro/util/headerreader"
+)
+
+func TestBatcherAddrMonitor(t *testing.T) {
+	initAddr1 := common.HexToAddress("0x1234567890123456789012345678901234567890")
+	initAddr2 := common.HexToAddress("0x2345678901234567890123456789012345678901")
+	initAddresses := []common.Address{
+		initAddr1,
+		initAddr2,
+	}
+	// Test initial state
+	t.Run("initial state", func(t *testing.T) {
+		caffDb, err := authdb.NewAuthDB(rawdb.NewMemoryDatabase(), nil, true)
+		Require(t, err)
+
+		_ = NewBatcherAddrMonitor(initAddresses, &caffDb, nil, common.Address{}, 0, 0, 100)
+	})
+
+	t.Run("store and restore", func(t *testing.T) {
+		dummyClient := &ethclient.Client{}
+		l1Reader, err := headerreader.New(context.Background(), dummyClient, nil, nil)
+		Require(t, err)
+		caffDb, err := authdb.NewAuthDB(rawdb.NewMemoryDatabase(), nil, true)
+		Require(t, err)
+		b := NewBatcherAddrMonitor(initAddresses, &caffDb, l1Reader, common.Address{}, 0, 0, 100)
+		b.lastProcessedParentHeight = 100
+		b.eventUpdatesAt = []uint64{100, 200}
+		err = b.Store()
+		Require(t, err)
+
+		err = b.Restore()
+		Require(t, err)
+		assert.Equal(t, uint64(100), b.lastProcessedParentHeight)
+		assert.Equal(t, []uint64{100, 200}, b.eventUpdatesAt)
+
+		b = NewBatcherAddrMonitor(initAddresses, &caffDb, l1Reader, common.Address{}, 0, 0, 100)
+		b.lastProcessedParentHeight = 100
+		b.eventUpdatesAt = []uint64{100, 200}
+		err = b.Store()
+		Require(t, err)
+		b.lastProcessedParentHeight = 10
+		b.eventUpdatesAt = []uint64{}
+		b.fromParentBlock = 101
+		err = b.Restore()
+		Require(t, err)
+
+		assert.Equal(t, uint64(10), b.lastProcessedParentHeight)
+		assert.Equal(t, []uint64{}, b.eventUpdatesAt)
+
+	})
+
+	t.Run("IsValid with no events", func(t *testing.T) {
+		ctx := context.Background()
+		caffDb, err := authdb.NewAuthDB(rawdb.NewMemoryDatabase(), nil, true)
+		Require(t, err)
+
+		b := NewBatcherAddrMonitor(initAddresses, &caffDb, nil, common.Address{}, 0, 0, 100)
+		// No events have been recorded yet; IsValid should return an error.
+		ok, err := b.IsValid(ctx, initAddr1, 100)
+		assert.False(t, ok)
+		assert.Error(t, err)
+	})
+
+	t.Run("IsValid uses cached results", func(t *testing.T) {
+		ctx := context.Background()
+		caffDb, err := authdb.NewAuthDB(rawdb.NewMemoryDatabase(), nil, true)
+		Require(t, err)
+
+		b := &BatcherAddrMonitor{
+			bufferWindow: 0,
+			// Two update points; we will target the first cache entry.
+			eventUpdatesAt: []uint64{100, 200},
+			validityCaches: []map[common.Address]bool{
+				{initAddr1: true, initAddr2: false},
+				{initAddr2: false},
+			},
+			// db is not used in IsValid, but keep it non-nil for completeness.
+			db:                        &caffDb,
+			lastProcessedParentHeight: 300,
+			lastProcessedL1Height:     300,
+		}
+
+		// height = l1Height - bufferWindow = 150, so index will resolve to 0
+		// and use the first cache map, where initAddr1 is true.
+		ok, err := b.IsValid(ctx, initAddr1, 150)
+		Require(t, err)
+		assert.True(t, ok)
+
+		// For a height that falls into the second interval, it should use
+		// the second cache map, where initAddr2 is false.
+		ok, err = b.IsValid(ctx, initAddr2, 250)
+		Require(t, err)
+		assert.False(t, ok)
+
+		b.bufferWindow = 64
+		ok, err = b.IsValid(ctx, initAddr2, 250)
+		Require(t, err)
+		assert.False(t, ok)
+	})
+}
diff --git a/arbnode/espresso_batcher_addr_simple_monitor.go b/arbnode/espresso_batcher_addr_simple_monitor.go
new file mode 100644
index 00000000000..a77e977993a
--- /dev/null
+++ b/arbnode/espresso_batcher_addr_simple_monitor.go
@@ -0,0 +1,50 @@
+package arbnode
+
+import (
+	"context"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type AddressValidRangeConfig struct {
+	Address string `koanf:"address"`
+	From    uint64 `koanf:"from"`
+	To      uint64 `koanf:"to"`
+}
+
+type AddressValidRange struct {
+	Address common.Address `koanf:"address"`
+	from    uint64         `koanf:"from"`
+	to      uint64         `koanf:"to"`
+}
+
+type BatcherAddrSimpleMonitor struct {
+	addressValidRanges []AddressValidRange
+}
+
+func NewBatcherAddrSimpleMonitor(addressValidRanges []AddressValidRangeConfig) *BatcherAddrSimpleMonitor {
+	converted := make([]AddressValidRange, 0, len(addressValidRanges))
+	for _, cfg := range addressValidRanges {
+		converted = append(converted, AddressValidRange{
+			Address: common.HexToAddress(cfg.Address),
+			from:    cfg.From,
+			to:      cfg.To,
+		})
+	}
+	return &BatcherAddrSimpleMonitor{
+		addressValidRanges: converted,
+	}
+}
+
+func (b *BatcherAddrSimpleMonitor) IsValid(ctx context.Context, batcherAddress common.Address, l1Height uint64) (bool, error) {
+	for _, addr := range b.addressValidRanges {
+		if addr.Address == batcherAddress {
+			return l1Height >= addr.from && l1Height <= addr.to, nil
+		}
+	}
+	return false, nil
+}
+
+func (b *BatcherAddrSimpleMonitor) Start(ctx context.Context) error {
+	return nil
+}
diff --git a/arbnode/espresso_batcher_addr_simple_monitor_test.go b/arbnode/espresso_batcher_addr_simple_monitor_test.go
new file mode 100644
index 00000000000..6ded7c78dff
--- /dev/null
+++ b/arbnode/espresso_batcher_addr_simple_monitor_test.go
@@ -0,0 +1,72 @@
+package arbnode
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+func TestBatcherAddrSimpleMonitor_IsValid(t *testing.T) {
+	ctx := context.Background()
+
+	addr1Str := "0x1234567890123456789012345678901234567890"
+	addr2Str := "0x2345678901234567890123456789012345678901"
+
+	cfgs := []AddressValidRangeConfig{
+		{
+			Address: addr1Str,
+			From:    0,
+			To:      100,
+		},
+		{
+			Address: addr2Str,
+			From:    50,
+			To:      150,
+		},
+	}
+
+	monitor := NewBatcherAddrSimpleMonitor(cfgs)
+
+	addr1 := common.HexToAddress(addr1Str)
+	addr2 := common.HexToAddress(addr2Str)
+	addr3 := common.HexToAddress("0x3456789012345678901234567890123456789012")
+
+	t.Run("within first range", func(t *testing.T) {
+		ok, err := monitor.IsValid(ctx, addr1, 50)
+		assert.NoError(t, err)
+		assert.True(t, ok)
+	})
+
+	t.Run("below first range", func(t *testing.T) {
+		ok, err := monitor.IsValid(ctx, addr1, 0)
+		assert.NoError(t, err)
+		assert.True(t, ok)
+	})
+
+	t.Run("above first range", func(t *testing.T) {
+		ok, err := monitor.IsValid(ctx, addr1, 101)
+		assert.NoError(t, err)
+		assert.False(t, ok)
+	})
+
+	t.Run("within second range", func(t *testing.T) {
+		ok, err := monitor.IsValid(ctx, addr2, 100)
+		assert.NoError(t, err)
+		assert.True(t, ok)
+	})
+
+	t.Run("outside any range", func(t *testing.T) {
+		ok, err := monitor.IsValid(ctx, addr2, 151)
+		assert.NoError(t, err)
+		assert.False(t, ok)
+	})
+
+	t.Run("unknown address", func(t *testing.T) {
+		ok, err := monitor.IsValid(ctx, addr3, 75)
+		assert.NoError(t, err)
+		assert.False(t, ok)
+	})
+}
diff --git a/arbnode/espresso_caff_node.go b/arbnode/espresso_caff_node.go
new file mode 100644
index 00000000000..f5275fcfe83
--- /dev/null
+++ b/arbnode/espresso_caff_node.go
@@ -0,0 +1,638 @@
+package arbnode
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"errors"
+	"fmt"
+	"hash"
+	"math/big"
+	"path"
+	"path/filepath"
+	"time"
+
+	espressoClient "github.com/EspressoSystems/espresso-network/sdks/go/client"
+	flag "github.com/spf13/pflag"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/node"
+
+	"github.com/offchainlabs/nitro/arbnode/dataposter"
+	"github.com/offchainlabs/nitro/arbos"
+	"github.com/offchainlabs/nitro/cmd/genericconf"
+	"github.com/offchainlabs/nitro/espresso/authdb"
+	espresso_key_manager "github.com/offchainlabs/nitro/espresso/key-manager"
+	"github.com/offchainlabs/nitro/espressostreamer"
+	"github.com/offchainlabs/nitro/espressotee"
+	"github.com/offchainlabs/nitro/execution/gethexec"
+	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
+	"github.com/offchainlabs/nitro/util/headerreader"
+	"github.com/offchainlabs/nitro/util/stopwaiter"
+)
+
+type EspressoCaffNodeInitArgs struct {
+	InitializeCaffNodeTags bool
+	CaffNodePrivateKey     *ecdsa.PrivateKey
+	CaffNodetxOpts         *bind.TransactOpts
+	TeeHMAC                hash.Hash
+}
+
+type EspressoCaffNodeConfig struct {
+	Enable                 bool                    `koanf:"enable"`
+	HotShotUrl             string                  `koanf:"hotshot-url"`
+	Namespace              uint64                  `koanf:"namespace"`
+	HotshotPollingInterval time.Duration           `koanf:"hotshot-polling-interval"`
+	HotshotPollingTimeout  time.Duration           `koanf:"hotshot-polling-timeout"`
+	SGXVerifierAddr        string                  `koanf:"sgx-verifier-addr"`
+	BatchPosterAddr        string                  `koanf:"batch-poster-addr"`
+	RecordPerformance      bool                    `koanf:"record-performance"`
+	WaitForFinalization    bool                    `koanf:"wait-for-finalization"`
+	RequiredBlockDepth     uint64                  `koanf:"required-block-depth"`
+	Dangerous              DangerousCaffNodeConfig `koanf:"dangerous"`
+	TeeType                string                  `koanf:"tee-type"`
+
+	// SGX specific config, leave empty if not using SGX
+	TEEVerifierAddr string `koanf:"tee-verifier-addr"`
+
+	// AWS Nitro Attestation Service URL
+	AttestationServiceURL string `koanf:"attestation-service-url"`
+
+	// Data poster config
+	DataPoster        dataposter.DataPosterConfig `koanf:"data-poster" reload:"hot"`
+	ParentChainWallet genericconf.WalletConfig    `koanf:"parent-chain-wallet"`
+
+	// Force Inclusion Checker
+	ForceInclusionChecker ForceInclusionCheckerConfig `koanf:"force-inclusion-checker"`
+	StateChecker          StateCheckerConfig          `koanf:"state-checker"`
+
+	KeyPairAttestationsPath string `koanf:"key-pair-attestations-path"`
+	SnapshotChecksum        string `koanf:"snapshot-checksum"`
+	GenerateSnapshot        bool   `koanf:"generate-snapshot"`
+	AuthDBBatchSize         int    `koanf:"auth-db-batch-size"`
+}
+
+func (c *EspressoCaffNodeConfig) ResolveDirectoryNames(chain string) {
+	// Make wallet directories relative to chain directory if specified and not already absolute
+	if len(c.KeyPairAttestationsPath) != 0 && !filepath.IsAbs(c.KeyPairAttestationsPath) {
+		c.KeyPairAttestationsPath = path.Join(chain, c.KeyPairAttestationsPath)
+	}
+}
+
+type DangerousCaffNodeConfig struct {
+	IgnoreDatabaseHotshotBlock bool `koanf:"ignore-database-hotshot-block"`
+	IgnoreDatabaseFromBlock    bool `koanf:"ignore-database-from-block"`
+}
+
+var DefaultDangerousCaffNodeConfig = DangerousCaffNodeConfig{
+	IgnoreDatabaseHotshotBlock: false,
+	IgnoreDatabaseFromBlock:    false,
+}
+
+var DefaultEspressoCaffNodeConfig = EspressoCaffNodeConfig{
+	Enable:                 false,
+	HotShotUrl:             "",
+	Namespace:              0,
+	HotshotPollingInterval: time.Millisecond * 100,
+	HotshotPollingTimeout:  time.Minute * 2,
+	SGXVerifierAddr:        "",
+	BatchPosterAddr:        "",
+	RecordPerformance:      false,
+	// Setting these values to the default
+	// values set by Arbitrum
+	WaitForFinalization:     false,
+	RequiredBlockDepth:      20,
+	Dangerous:               DefaultDangerousCaffNodeConfig,
+	KeyPairAttestationsPath: "caff_node_key_pair_attestations",
+	TeeType:                 "",
+	AttestationServiceURL:   "",
+	TEEVerifierAddr:         "",
+	DataPoster:              dataposter.DefaultDataPosterConfig,
+	SnapshotChecksum:        "",
+	ParentChainWallet:       DefaultBatchPosterL1WalletConfig,
+	GenerateSnapshot:        false,
+	AuthDBBatchSize:         10000,
+	StateChecker:            DefaultStateCheckerConfig,
+	ForceInclusionChecker:   DefaultEspressoForceInclusionCheckerConfig,
+}
+
+func EspressoCaffNodeConfigAddOptions(prefix string, f *flag.FlagSet) {
+	f.Bool(prefix+".enable", DefaultEspressoCaffNodeConfig.Enable, "enable espresso Caff node")
+	f.String(prefix+".hotshot-url", DefaultEspressoCaffNodeConfig.HotShotUrl, "Hotshot url")
+	f.Uint64(prefix+".namespace", DefaultEspressoCaffNodeConfig.Namespace, "the namespace of the chain in Espresso Network, usually the chain id")
+	f.Duration(prefix+".hotshot-polling-interval", DefaultEspressoCaffNodeConfig.HotshotPollingInterval, "time after a success")
+	f.Duration(prefix+".hotshot-polling-timeout", DefaultEspressoCaffNodeConfig.HotshotPollingTimeout, "timeout for hotshot polling")
+	f.String(prefix+".sgx-verifier-addr", DefaultEspressoCaffNodeConfig.SGXVerifierAddr, "espresso legacy SGX verifier address that is used to verify the signature of the Hotshot transactions")
+	f.String(prefix+".batch-poster-addr", DefaultEspressoCaffNodeConfig.BatchPosterAddr, "batch poster address that is used to verify the signature of the Hotshot transactions")
+	f.Bool(prefix+".record-performance", DefaultEspressoCaffNodeConfig.RecordPerformance, "record performance of the Caff node")
+	f.Bool(prefix+".wait-for-finalization", DefaultEspressoCaffNodeConfig.WaitForFinalization, "Configures the Caff node to only produce blocks from delayed messages if they are finalized on the parent chain")
+	f.Uint64(prefix+".required-block-depth", DefaultEspressoCaffNodeConfig.RequiredBlockDepth, "Configures the required block depth/number of confirmations on the parent chain that a delayed message is required to have before this Caff node will add it to it's state")
+	f.String(prefix+".key-pair-attestations-path", DefaultEspressoCaffNodeConfig.KeyPairAttestationsPath, "Path to attestation documents with KMSKeyID, EncryptedPrivateKey attestations")
+	f.String(prefix+".snapshot-checksum", DefaultEspressoCaffNodeConfig.SnapshotChecksum, "Configures the snapshot checksum")
+	f.String(prefix+".tee-type", DefaultEspressoCaffNodeConfig.TeeType, "The Trusted Execution Environment (TEE) that Caff node is running in")
+	f.String(prefix+".attestation-service-url", DefaultEspressoBatchPosterConfig.AttestationServiceURL, "URL of the attestation service to use for obtaining zk proof over  attestation")
+	genericconf.WalletConfigAddOptions(prefix+".parent-chain-wallet", f, DefaultBatchPosterConfig.ParentChainWallet.Pathname)
+	f.String(prefix+".tee-verifier-addr", DefaultEspressoCaffNodeConfig.TEEVerifierAddr, "Address of the EspressoTEEVerifier contract utilize for handling cross chain NFT verification")
+	DangerousCaffNodeConfigAddOptions(prefix+".dangerous", f)
+	f.Bool(prefix+".generate-snapshot", DefaultEspressoCaffNodeConfig.GenerateSnapshot, "Configures whether to generate a snapshot")
+	f.Int(prefix+".auth-db-batch-size", DefaultEspressoCaffNodeConfig.AuthDBBatchSize, "Batch size to use when initializing auth tags in the AuthDB")
+	dataposter.DataPosterConfigAddOptions(prefix+".data-poster", f, dataposter.DefaultDataPosterConfig, dataposter.DataPosterUsageCaffNode)
+
+	EspressoForceInclusionConfigAddOptions(prefix+".force-inclusion-checker", f)
+	EspressoStateCheckerConfigAddOptions(prefix+".state-checker", f)
+}
+
+func DangerousCaffNodeConfigAddOptions(prefix string, f *flag.FlagSet) {
+	f.Bool(prefix+".ignore-database-hotshot-block", DefaultDangerousCaffNodeConfig.IgnoreDatabaseHotshotBlock, "Ignores the database hotshot block and starts from the next block specified in the config by the user")
+	f.Bool(prefix+".ignore-database-from-block", DefaultDangerousCaffNodeConfig.IgnoreDatabaseFromBlock, "Ignores the database from block and starts from the next block specified in the config by the user")
+}
+
+type EspressoCaffNodeConfigFetcher func() *EspressoCaffNodeConfig
+
+type EspressoCaffNode struct {
+	stopwaiter.StopWaiter
+
+	executionEngine  *gethexec.ExecutionEngine
+	espressoStreamer espressostreamer.EspressoStreamerInterface
+
+	configFetcher EspressoCaffNodeConfigFetcher
+	db            *authdb.AuthDB
+
+	delayedMessageFetcher DelayedMessageFetcherInterface
+
+	l1Reader *headerreader.HeaderReader
+
+	forceInclusionChecker *ForceInclusionChecker
+	stateChecker          *StateChecker
+
+	batcherAddrMonitor *BatcherAddrMonitor
+	currentBlock       *types.Block
+	snapshotHandler    *EspressoSnapshotHandler
+	keyManager         *espresso_key_manager.EspressoKeyManager
+	dataPoster         *dataposter.DataPoster
+	caffNodePrivateKey *ecdsa.PrivateKey
+
+	streamerConfigFetcher EspressoStreamerConfigFetcher
+}
+
+func NewEspressoCaffNode(
+	ctx context.Context,
+	configFetcher EspressoCaffNodeConfigFetcher,
+	chainDb ethdb.Database,
+	execEngine *gethexec.ExecutionEngine,
+	delayedBridge *DelayedBridge,
+	l1Reader *headerreader.HeaderReader,
+	recordPerformance bool,
+	sequencerInbox *SequencerInbox,
+	fatalErrChan chan error,
+	stack *node.Node,
+	dataPosterDB ethdb.Database,
+	caffNodeInitArgs *EspressoCaffNodeInitArgs,
+	streamerConfigFetcher EspressoStreamerConfigFetcher,
+) (*EspressoCaffNode, error) {
+	if !configFetcher().Enable {
+		return nil, nil
+	}
+
+	if l1Reader == nil {
+		return nil, fmt.Errorf("l1 reader is nil")
+	}
+	teeType, err := espressotee.FromString(configFetcher().TeeType)
+	if err != nil {
+		return nil, fmt.Errorf("Error parsing TEE type, %w", err)
+	}
+
+	var db authdb.AuthDB
+	if configFetcher().TeeType != "" {
+		log.Info("initialiing auth db with", "i", caffNodeInitArgs.InitializeCaffNodeTags)
+		// if we need to initialize caff node tags, then we will disable auth reads
+		db, err = authdb.NewAuthDB(chainDb, caffNodeInitArgs.TeeHMAC, caffNodeInitArgs.InitializeCaffNodeTags)
+	} else {
+		// Outside the tee, we need to remove tmac and also disable auth reads
+		db, err = authdb.NewAuthDB(chainDb, nil, true)
+	}
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to create auth db: %w", err)
+	}
+
+	// For backward compatibility, the espresso streamer should be able to verify legacy where we signed
+	// hotshot transactions using SGX quote. Therefore we create a SGX TEE verifier here.
+	sgxVerifier, err := espressotee.NewEspressoSGXVerifier(
+		l1Reader.Client(),
+		common.HexToAddress(configFetcher().SGXVerifierAddr),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create espressoTEEVerifier: %w", err)
+	}
+	client := espressoClient.NewClient(configFetcher().HotShotUrl)
+
+	fromBlock := streamerConfigFetcher().AddressMonitorStartL1
+
+	if !configFetcher().Dangerous.IgnoreDatabaseFromBlock {
+		fromBlock, err = authdb.ReadFromBlock(&db)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read l1 block from db: %w", err)
+		}
+	}
+	if fromBlock == 0 {
+		fromBlock = streamerConfigFetcher().AddressMonitorStartL1
+		if fromBlock == 0 {
+			return nil, fmt.Errorf("fromBlock is 0, please provide a valid block number")
+		}
+	}
+
+	batcherAddrMonitor := NewBatcherAddrMonitor(
+		[]common.Address{common.HexToAddress(configFetcher().BatchPosterAddr)},
+		&db,
+		l1Reader,
+		sequencerInbox.address,
+		delayedBridge.fromBlock,
+		fromBlock,
+		streamerConfigFetcher().AddressMonitorStep,
+	)
+	espressoStreamer := espressostreamer.NewEspressoStreamer(configFetcher().Namespace,
+		streamerConfigFetcher().HotShotBlock,
+		sgxVerifier,
+		client,
+		recordPerformance,
+		func(l1Height uint64, addr common.Address) (bool, error) {
+			return batcherAddrMonitor.IsValid(ctx, addr, l1Height)
+		},
+		streamerConfigFetcher().TxnsPollingInterval,
+	)
+
+	delayedMessageFetcher := NewDelayedMessageFetcher(delayedBridge, l1Reader,
+		configFetcher().WaitForFinalization, configFetcher().RequiredBlockDepth, fromBlock, sequencerInbox, fatalErrChan)
+
+	seqInbox, err := bridgegen.NewSequencerInbox(sequencerInbox.address, l1Reader.Client())
+	if err != nil {
+		return nil, fmt.Errorf("failed to create sequencer inbox: %w", err)
+	}
+
+	forceInclusionChecker := NewForceInclusionChecker(
+		&SeqInbox{seqInbox: seqInbox},
+		configFetcher().ForceInclusionChecker,
+		l1Reader,
+		delayedMessageFetcher,
+		fatalErrChan,
+	)
+
+	stateChecker := NewStateChecker(
+		configFetcher().StateChecker,
+		stack.Config().HTTPPort,
+		fatalErrChan,
+	)
+
+	// Create a new EspressoKeyManager
+	// Get the EspressoTEEVerifier address from SequencerInbox contract
+	configAddress := configFetcher().TEEVerifierAddr
+	var espressoTEEVerifierAddress common.Address
+	// parse the espresso tee verifier address from config if it exists, otherwise read from the sequencerInbox
+	// Eventually we should only read from the SequencerInbox
+	if configAddress != "" && common.IsHexAddress(configAddress) {
+		espressoTEEVerifierAddress = common.HexToAddress(configAddress)
+	} else {
+		espressoTEEVerifierAddress, err = sequencerInbox.con.EspressoTEEVerifier(&bind.CallOpts{})
+	}
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to get EspressoTEEVerifier address: %w", err)
+	}
+	verifier := espressotee.NewEspressoTEEVerifier(espressoTEEVerifierAddress.Hex(), l1Reader.Client(), espressoTEEVerifierAddress)
+
+	var dataPoster *dataposter.DataPoster
+	var keyManager *espresso_key_manager.EspressoKeyManager
+	var snapshotHandler *EspressoSnapshotHandler
+	if teeType != espressotee.EMPTY {
+		if caffNodeInitArgs.CaffNodetxOpts == nil {
+			return nil, fmt.Errorf("non nil txOpts are required to run the Caff Node in a TEE")
+		}
+
+		dataPosterConfigFetcher := func() *dataposter.DataPosterConfig {
+			dpCfg := configFetcher().DataPoster
+			return &dpCfg
+		}
+
+		chainId, err := l1Reader.Client().ChainID(ctx)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get chain id: %w", err)
+		}
+
+		dataPoster, err := dataposter.NewDataPoster(ctx,
+			&dataposter.DataPosterOpts{
+				Database:      dataPosterDB,
+				HeaderReader:  l1Reader,
+				Auth:          caffNodeInitArgs.CaffNodetxOpts,
+				Config:        dataPosterConfigFetcher,
+				ParentChainID: chainId,
+				MetadataRetriever: func(ctx context.Context, blockNum *big.Int) ([]byte, error) {
+					return nil, nil
+				},
+			})
+		if err != nil {
+			return nil, fmt.Errorf("failed to create data poster: %w", err)
+		}
+
+		caffNodeServiceType := espressotee.CaffNode
+		if teeType == espressotee.TESTS {
+			caffNodeServiceType = espressotee.Test
+		}
+		keyManager = espresso_key_manager.NewEspressoKeyManager(verifier, dataPoster, nil, teeType, caffNodeServiceType, caffNodeInitArgs.CaffNodePrivateKey, configFetcher().AttestationServiceURL, "", 0)
+
+	}
+	initializeCaffNodeTags := false
+	var caffNodePrivateKey *ecdsa.PrivateKey
+	if caffNodeInitArgs != nil {
+		initializeCaffNodeTags = caffNodeInitArgs.InitializeCaffNodeTags
+		caffNodePrivateKey = caffNodeInitArgs.CaffNodePrivateKey
+	}
+
+	snapshotHandler = NewEspressoSnapshotHandler(&db, stack.InstanceDir(), stack.ResolvePath("l2chaindata"), initializeCaffNodeTags, keyManager, configFetcher().GenerateSnapshot, configFetcher().AuthDBBatchSize)
+
+	return &EspressoCaffNode{
+		configFetcher:         configFetcher,
+		executionEngine:       execEngine,
+		delayedMessageFetcher: delayedMessageFetcher,
+		espressoStreamer:      espressoStreamer,
+		db:                    &db,
+		l1Reader:              l1Reader,
+		forceInclusionChecker: forceInclusionChecker,
+		stateChecker:          stateChecker,
+		batcherAddrMonitor:    batcherAddrMonitor,
+		snapshotHandler:       snapshotHandler,
+		keyManager:            keyManager,
+		dataPoster:            dataPoster,
+		caffNodePrivateKey:    caffNodePrivateKey,
+		streamerConfigFetcher: streamerConfigFetcher,
+	}, nil
+}
+
+// peekMessage wraps the espressoStreamer.Peek() method, to handle producing delayed messages by checking they are within the nodes safety tolerance.
+// Returns:
+//   - MessageWithMetadataAndPos: A message, delayed or normally sequenced, that is for the next position in the chain.
+//   - error: If any error is encountered during this function it is propegated to the caller.
+//
+// Semantics:
+//
+//	This function will either produce a message, or an error. When an error is produced, the messageWithMetadataAndPos will be nil.
+//	If the message is populated, the error will be nil.
+func (n *EspressoCaffNode) peekMessage(ctx context.Context) (*espressostreamer.MessageWithMetadataAndPos, uint64, error) {
+	messageWithMetadataAndPos := n.espressoStreamer.Peek()
+
+	if messageWithMetadataAndPos == nil {
+		return nil, 0, nil
+	}
+
+	// Check if its a delayed message, if so fetch from the database
+	delayedMessageToProcessIndex, err := n.executionEngine.NextDelayedMessageNumber()
+	if err != nil {
+		log.Error("failed to get next delayed message number", "err", err)
+		return nil, 0, err
+	}
+	if delayedMessageToProcessIndex == messageWithMetadataAndPos.MessageWithMeta.DelayedMessagesRead-1 {
+		messageWithMetadataAndPosDelayed, fromBlock, err := n.delayedMessageFetcher.processDelayedMessage(messageWithMetadataAndPos)
+		if err != nil {
+			log.Error("unable to get the next delayed message", "err", err)
+			return nil, 0, err
+		}
+		return messageWithMetadataAndPosDelayed, fromBlock, nil
+	}
+
+	return messageWithMetadataAndPos, 0, nil
+}
+
+// Creates a block from the next message in the queue.
+func (n *EspressoCaffNode) createBlock(ctx context.Context) (returnValue bool) {
+	lastBlockHeader := n.currentBlock.Header()
+
+	messageWithMetadataAndPos, fromBlock, err := n.peekMessage(ctx)
+	if err != nil {
+		log.Warn("unable to get next message", "err", err)
+		return false
+	}
+
+	if messageWithMetadataAndPos == nil {
+		// No message found, so we need to wait for the next message
+		return false
+	}
+
+	messageWithMetadata := messageWithMetadataAndPos.MessageWithMeta
+
+	// Get the state of the database at the last block
+	statedb, err := n.executionEngine.Bc().StateAt(lastBlockHeader.Root)
+	if err != nil {
+		log.Error("failed to get state at last block header", "err", err)
+		return false
+	}
+
+	log.Info("Initial State", "lastBlockHash", lastBlockHeader.Hash(), "lastBlockStateRoot", lastBlockHeader.Root)
+	startTime := time.Now()
+
+	// Run the Produce block function in replay mode
+	// This is the core function that is used by replay.wasm to validate the block
+	block, receipts, err := arbos.ProduceBlock(messageWithMetadata.Message,
+		messageWithMetadata.DelayedMessagesRead,
+		lastBlockHeader,
+		statedb,
+		n.executionEngine.Bc(),
+		false,
+		core.NewMessageReplayContext(),
+		false,
+	)
+
+	if err != nil || block == nil {
+		log.Error("Failed to produce block", "err", err)
+		return false
+	}
+
+	blockCalcTime := time.Since(startTime)
+
+	log.Info("Produced block", "block", block.Hash(), "blockNumber", block.Number(), "receipts", len(receipts))
+
+	// Check for next position hotshot block number since we processed this one
+	hotshotBlockNumber := n.espressoStreamer.GetCurrentEarliestHotShotBlockNumber(messageWithMetadataAndPos.Pos + 1)
+	batch := n.db.NewBatch()
+
+	// Store hotshot block num with auth tag
+	if err := authdb.WriteNextHotshotBlockNum(batch, hotshotBlockNumber); err != nil {
+		log.Error("failed to store NextHotshotBlockNum and its auth tag", "err", err)
+		return false
+	}
+
+	// Store from block with signature if snapshot signer is configured
+	// fromBlock will only be stored when we process a delayed message
+	if fromBlock != 0 {
+		if err := authdb.WriteFromBlock(batch, fromBlock); err != nil {
+			log.Error("failed to store delayedMessageFetcherFromBlock and its auth tag", "err", err)
+			return false
+		}
+	}
+
+	// the `AuthDB.Put()` adds the auth tags alongside the content of block header, body, and receipts
+	err = n.executionEngine.AppendBlock(block, statedb, receipts, blockCalcTime)
+	if err != nil {
+		log.Error("Failed to append block", "err", err)
+		return false
+	}
+
+	// Write the batch to the database
+	if err := batch.Write(); err != nil {
+		log.Error("caff node create block failed to write block to db", "err", err)
+		return false
+	}
+
+	n.currentBlock = block
+	n.espressoStreamer.Advance()
+
+	n.executionEngine.Bc().SetFinalized(block.Header())
+	n.executionEngine.Bc().SetSafe(block.Header())
+	n.espressoStreamer.RecordTimeDurationBetweenHotshotAndCurrentBlock(messageWithMetadataAndPos.HotshotHeight, time.Now())
+
+	return true
+}
+
+func (n *EspressoCaffNode) GetEspressoStreamer() espressostreamer.EspressoStreamerInterface {
+	return n.espressoStreamer
+}
+
+func (n *EspressoCaffNode) Start(ctx context.Context) error {
+	n.StopWaiter.Start(ctx, n)
+
+	if n.configFetcher().TeeType == "" && n.configFetcher().SnapshotChecksum != "" {
+		return fmt.Errorf("espresso tee type is required when trying to verify a snapshot checksum")
+	}
+
+	err := n.snapshotHandler.Start(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to start snapshot verifier: %w", err)
+	}
+
+	if n.keyManager != nil {
+		for {
+			registered, err := n.keyManager.CheckRegistration()
+			state := n.keyManager.GetKeyManagerState()
+			if err != nil {
+				log.Warn("caff node address not registered on chain yet...", "current key manager state", state, "err", err)
+				if errors.Is(err, espresso_key_manager.FatalErrUnableToRegisterSigner) {
+					log.Warn(
+						"Espresso signer registration failed consecutively. Stopping.",
+						"retries", espressotee.EspressoMaxRetries,
+					)
+
+					log.Crit("caff node failed to failed to register signer")
+				}
+			}
+			if registered {
+				log.Info("caff node address is registered on chain")
+				break
+			}
+			if err == nil {
+				log.Info("caff node address not registered", "current key manager state", state)
+			}
+			select {
+			case <-ctx.Done():
+				return ctx.Err()
+			case <-time.After(espressotee.EspressoRetryReadContractDelay):
+			}
+		}
+	}
+
+	err = n.espressoStreamer.Start(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to start espresso streamer: %w", err)
+	}
+	err = n.batcherAddrMonitor.Start(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to start batcher address monitor: %w", err)
+	}
+	err = n.forceInclusionChecker.Start(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to start force inclusion checker: %w", err)
+	}
+
+	if n.stateChecker != nil {
+		err = n.stateChecker.Start(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to start state checker: %w", err)
+		}
+	}
+
+	// This is +1 because the current block is the block after the last processed block
+	currentBlockHeader := n.executionEngine.Bc().CurrentBlock()
+	currentBlock := n.executionEngine.Bc().GetBlock(currentBlockHeader.Hash(), currentBlockHeader.Number.Uint64())
+
+	n.currentBlock = currentBlock
+
+	currentBlockNum := currentBlockHeader.Number.Uint64() + 1
+	currentMessagePos, err := n.executionEngine.BlockNumberToMessageIndex(currentBlockNum)
+	if err != nil {
+		return fmt.Errorf("failed to convert block number to message index: %w", err)
+	}
+
+	var nextHotshotBlock uint64
+
+	if !n.configFetcher().Dangerous.IgnoreDatabaseHotshotBlock {
+		nextHotshotBlock, err = authdb.ReadNextHotshotBlockNum(n.db)
+		if err != nil {
+			return fmt.Errorf("failed to read next hotshot block: %w", err)
+		}
+	}
+	if nextHotshotBlock == 0 {
+		// No next hotshot block found, so we need to start from config.CaffNodeConfig.NextHotshotBlock
+		nextHotshotBlock = n.streamerConfigFetcher().HotShotBlock
+		if nextHotshotBlock == 0 {
+			return errors.New("no next hotshot block found in database or dangerous.ignore-database-hotshot-block is set to true, please set config.CaffNodeConfig.NextHotshotBlock")
+		}
+	}
+
+	// The reason we do the reset here is because database is only initialized after Caff node is initialized
+	// so if we want to read the current position from the database, we need to reset the streamer
+	// during the start of the espresso streamer and caff node
+	log.Info("Starting streamer at", "nextHotshotBlock", nextHotshotBlock, "currentMessagePos", currentMessagePos)
+	n.espressoStreamer.Reset(uint64(currentMessagePos), nextHotshotBlock)
+
+	// Nonce of the previous block is the number of delayed messages read
+	// Check `NextDelayedMessageNumber` in execution node to confirm this
+	delayedMessagesRead := n.executionEngine.Bc().CurrentBlock().Nonce.Uint64()
+	// we store delayedmessagecount-1 because that is the index of the delayed message
+	// that needs to be read
+	n.delayedMessageFetcher.storeDelayedMessageLatestIndex(delayedMessagesRead - 1)
+
+	log.Debug("stored delayed message count", "delayedMessagesRead", delayedMessagesRead-1)
+
+	// Start the delayed message fetcher
+	started := n.delayedMessageFetcher.Start(ctx)
+	if !started {
+		return fmt.Errorf("failed to start delayed message fetcher")
+	}
+
+	log.Info("started delayed message fetcher")
+	log.Info("Caff Node successfully started")
+
+	err = n.CallIterativelySafe(func(ctx context.Context) time.Duration {
+		madeBlock := n.createBlock(ctx)
+		if madeBlock {
+			return n.configFetcher().HotshotPollingInterval
+		}
+		return n.streamerConfigFetcher().TxnsPollingInterval
+	})
+	if err != nil {
+		return fmt.Errorf("failed to start node, error in createBlock: %w", err)
+	}
+
+	return nil
+}
+
+func (n *EspressoCaffNode) StopAndWait() {
+	n.StopWaiter.StopAndWait()
+	n.batcherAddrMonitor.StopAndWait()
+	n.delayedMessageFetcher.StopAndWait()
+	n.espressoStreamer.StopAndWait()
+	n.forceInclusionChecker.StopAndWait()
+	n.snapshotHandler.StopAndWait()
+}
diff --git a/arbnode/espresso_caff_node_test.go b/arbnode/espresso_caff_node_test.go
new file mode 100644
index 00000000000..564a898f90b
--- /dev/null
+++ b/arbnode/espresso_caff_node_test.go
@@ -0,0 +1,199 @@
+package arbnode
+
+import (
+	"context"
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/params"
+
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+	"github.com/offchainlabs/nitro/cmd/chaininfo"
+	"github.com/offchainlabs/nitro/espressostreamer"
+	"github.com/offchainlabs/nitro/execution/gethexec"
+	"github.com/offchainlabs/nitro/statetransfer"
+	"github.com/offchainlabs/nitro/util/testhelpers/env"
+)
+
+type MockEspressoStreamer struct {
+	currPos     uint64
+	currHotShot uint64
+
+	delayedPos uint64
+	dbHotShot  uint64
+}
+
+// StopAndWait implements espressostreamer.EspressoStreamerInterface.
+func (m *MockEspressoStreamer) StopAndWait() {
+	panic("unimplemented")
+}
+
+var _ espressostreamer.EspressoStreamerInterface = (*MockEspressoStreamer)(nil)
+
+// SetBatcherAddressesFetcher implements espressostreamer.EspressoStreamerInterface.
+func (m *MockEspressoStreamer) SetBatcherAddressesFetcher(fetcher func(l1Height uint64, address common.Address) (bool, error)) {
+	panic("unimplemented")
+}
+
+func (m *MockEspressoStreamer) CanBatcherAddressSend(ctx context.Context, address common.Address) (bool, error) {
+	panic("unimplemented")
+}
+
+func (m *MockEspressoStreamer) GetCurrentEarliestHotShotBlockNumber(pos uint64) uint64 {
+	return m.currHotShot
+}
+
+func (m *MockEspressoStreamer) Start(ctx context.Context) error {
+	return nil
+}
+
+func (m *MockEspressoStreamer) Peek() *espressostreamer.MessageWithMetadataAndPos {
+	var delayedCnt uint64 = 1
+	if m.delayedPos == m.currPos {
+		delayedCnt = 2
+	}
+	result := espressostreamer.MessageWithMetadataAndPos{
+		MessageWithMeta: arbostypes.MessageWithMetadata{
+			DelayedMessagesRead: delayedCnt,
+			Message:             &arbostypes.EmptyTestIncomingMessage,
+		},
+		Pos:           m.currPos,
+		HotshotHeight: m.currHotShot,
+	}
+	return &result
+}
+
+func (m *MockEspressoStreamer) Advance() {
+	m.currPos++
+	m.currHotShot++
+}
+
+func (m *MockEspressoStreamer) Next() *espressostreamer.MessageWithMetadataAndPos {
+	result := m.Peek()
+	m.Advance()
+	return result
+}
+
+func (m *MockEspressoStreamer) Reset(currentMessagePos uint64, currentHostshotBlock uint64) {
+	m.currPos = currentMessagePos
+	m.currHotShot = currentHostshotBlock
+}
+
+func (m *MockEspressoStreamer) RecordTimeDurationBetweenHotshotAndCurrentBlock(nextHotshotBlock uint64, blockProductionTime time.Time) {
+}
+
+func (m *MockEspressoStreamer) StoreHotshotBlock(batch ethdb.Batch, nextHotshotBlock uint64) error {
+	return nil
+}
+
+type MockDelayedMessageFetcher struct{}
+
+// This function isn't a proper implementation for the tests, but this gets the test to compile.
+func (m *MockDelayedMessageFetcher) getDelayedMessageLatestIndexAtBlock(blockNumber uint64) (uint64, error) {
+	return 1, nil
+}
+
+func (m *MockDelayedMessageFetcher) processDelayedMessage(messageWithMetadataAndPos *espressostreamer.MessageWithMetadataAndPos) (*espressostreamer.MessageWithMetadataAndPos, uint64, error) {
+	if messageWithMetadataAndPos.MessageWithMeta.DelayedMessagesRead == 2 {
+		return &espressostreamer.MessageWithMetadataAndPos{
+			MessageWithMeta: arbostypes.MessageWithMetadata{
+				Message:             arbostypes.InvalidL1Message,
+				DelayedMessagesRead: messageWithMetadataAndPos.MessageWithMeta.DelayedMessagesRead,
+			},
+			Pos:           messageWithMetadataAndPos.Pos,
+			HotshotHeight: messageWithMetadataAndPos.HotshotHeight,
+		}, 0, nil
+	}
+	return messageWithMetadataAndPos, 0, nil
+}
+
+func (m *MockDelayedMessageFetcher) Start(ctx context.Context) bool {
+	return true
+}
+
+func (m *MockDelayedMessageFetcher) storeDelayedMessageLatestIndex(count uint64) {
+	return
+}
+
+func (m *MockDelayedMessageFetcher) StopAndWait() {
+	return
+}
+
+func TestEspressoCaffNodeShouldReadDelayedMessageFromL1(t *testing.T) {
+
+	caffNode := EspressoCaffNode{}
+
+	// create a test execution client
+	chainConfig := chaininfo.ArbitrumDevTestChainConfig()
+
+	initData := statetransfer.ArbosInitializationInfo{
+		Accounts: []statetransfer.AccountInitializationInfo{
+			{
+				Addr:       common.HexToAddress("0x1111111111111111111111111111111111111111"),
+				EthBalance: big.NewInt(params.Ether),
+			},
+		},
+	}
+
+	chainDb := rawdb.NewMemoryDatabase()
+	initReader := statetransfer.NewMemoryInitDataReader(&initData)
+
+	cacheConfig := core.DefaultConfig().WithStateScheme(env.GetTestStateScheme())
+	bc, err := gethexec.WriteOrTestBlockChain(chainDb, cacheConfig, initReader, chainConfig, nil, nil, arbostypes.TestInitMessage, &gethexec.ConfigDefault.TxIndexer, 0)
+
+	if err != nil {
+		Fail(t, err)
+	}
+
+	execEngine, err := gethexec.NewExecutionEngine(bc, 0, false)
+	if err != nil {
+		Fail(t, err)
+	}
+	caffNode.executionEngine = execEngine
+	caffNode.espressoStreamer = &MockEspressoStreamer{delayedPos: 3, currPos: 0}
+	caffNode.delayedMessageFetcher = &MockDelayedMessageFetcher{}
+	ctx := context.Background()
+	msg1, _, err := caffNode.peekMessage(ctx)
+	require.NoError(t, err)
+
+	require.Equal(t, msg1.MessageWithMeta.DelayedMessagesRead, uint64(1))
+	require.Equal(t, msg1.MessageWithMeta.Message, &arbostypes.EmptyTestIncomingMessage)
+	require.Equal(t, msg1.Pos, uint64(0))
+	caffNode.espressoStreamer.Advance()
+
+	msg2, _, err := caffNode.peekMessage(ctx)
+	require.NoError(t, err)
+	require.Equal(t, msg2.MessageWithMeta.DelayedMessagesRead, uint64(1))
+	require.Equal(t, msg2.MessageWithMeta.Message, &arbostypes.EmptyTestIncomingMessage)
+	require.Equal(t, msg2.Pos, uint64(1))
+	caffNode.espressoStreamer.Advance()
+
+	msg3, _, err := caffNode.peekMessage(ctx)
+	require.NoError(t, err)
+	require.Equal(t, msg3.MessageWithMeta.DelayedMessagesRead, uint64(1))
+	require.Equal(t, msg3.MessageWithMeta.Message, &arbostypes.EmptyTestIncomingMessage)
+	require.Equal(t, msg3.Pos, uint64(2))
+	caffNode.espressoStreamer.Advance()
+
+	msg4, _, err := caffNode.peekMessage(ctx)
+	require.NoError(t, err)
+	require.Equal(t, msg4.MessageWithMeta.DelayedMessagesRead, uint64(2))
+	require.Equal(t, msg4.MessageWithMeta.Message, arbostypes.InvalidL1Message)
+	require.Equal(t, msg4.Pos, uint64(3))
+}
+
+func TestEspressoCaffNodeShouldResetToLastStoredHotshotBlock(t *testing.T) {
+	caffNode := EspressoCaffNode{}
+	caffNode.espressoStreamer = &MockEspressoStreamer{delayedPos: 3, dbHotShot: 10}
+
+	espressoStreamer, _ := caffNode.espressoStreamer.(*MockEspressoStreamer)
+	require.Equal(t, espressoStreamer.dbHotShot, uint64(10))
+	require.Equal(t, espressoStreamer.delayedPos, uint64(3))
+}
diff --git a/arbnode/espresso_delayed_message_fetcher.go b/arbnode/espresso_delayed_message_fetcher.go
new file mode 100644
index 00000000000..62318a9206e
--- /dev/null
+++ b/arbnode/espresso_delayed_message_fetcher.go
@@ -0,0 +1,403 @@
+package arbnode
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"sort"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/offchainlabs/nitro/espressostreamer"
+	"github.com/offchainlabs/nitro/util/headerreader"
+	"github.com/offchainlabs/nitro/util/stopwaiter"
+)
+
+var (
+	DelayedFetcherCurrentFromBlockKey          = []byte("espressoDelayedFetcherCurrentFromBlock")
+	DelayedFetcherCurrentFromBlockSignatureKey = []byte("espressoDelayedFetcherCurrentFromBlockSignature")
+	DelayedMessageCountKey                     = []byte("espressoDelayedMessageCount")
+	// To not to mess with the existing schema, we use another prefix
+	DelayedMessagePrefix = []byte("espressoDelayed")
+)
+
+// The number of blocks to read from the parent chain for delayed messages
+const MaxBlocksToRead uint64 = 10000
+
+type DelayedMessageFetcher struct {
+	stopwaiter.StopWaiter
+
+	fromBlock                uint64
+	delayedBridge            *DelayedBridge
+	sequencerInbox           *SequencerInbox
+	l1Reader                 *headerreader.HeaderReader
+	waitForFinalization      bool
+	requiredBlockDepth       uint64
+	fatalErrChan             chan error
+	delayedCount             uint64
+	delayedMessages          map[uint64]*DelayedInboxMessage
+	delayedMessagesFromBlock map[uint64]uint64
+}
+
+type DelayedMessageFetcherInterface interface {
+	Start(ctx context.Context) bool
+	storeDelayedMessageLatestIndex(count uint64)
+	processDelayedMessage(messageWithMetadataAndPos *espressostreamer.MessageWithMetadataAndPos) (*espressostreamer.MessageWithMetadataAndPos, uint64, error)
+	getDelayedMessageLatestIndexAtBlock(blockNumber uint64) (uint64, error)
+	StopAndWait()
+}
+
+var _ DelayedMessageFetcherInterface = new(DelayedMessageFetcher)
+
+/*
+backfill fetches all delayed messages until `matureL1Block` which is within the safety tolerance of the rollup
+*/
+func (d *DelayedMessageFetcher) backfill(ctx context.Context) error {
+	// Get the l1 block number based on the read mode
+	matureL1Block, err := d.getL1BlockNumber(ctx)
+	if err != nil {
+		log.Error("Error getting l1 block number", "err", err)
+		return err
+	}
+
+	fromBlock := d.fromBlock
+	log.Info("backfilling delayed messages", "fromBlock", fromBlock, "matureL1Block", matureL1Block)
+
+	// Loop through the blocks until we reach the matureL1Block
+	for fromBlock < matureL1Block {
+		toBlock := matureL1Block
+		// If the difference is greater than the maxBlocksToRead,
+		// then set the endBlock to fromBlock + maxBlocksToRead
+		if (matureL1Block - fromBlock) > MaxBlocksToRead {
+			toBlock = fromBlock + MaxBlocksToRead
+		}
+
+		err := d.getDelayedMessagesInRange(ctx, fromBlock, toBlock)
+		if err != nil {
+			log.Error("failed to get delayed messages in range", "err", err, "fromBlock", fromBlock, "endBlock", toBlock)
+			return err
+		}
+		fromBlock = toBlock + 1
+	}
+
+	log.Info("Backfilled delayed messages")
+	return nil
+}
+
+/*
+startWatchDelayedMessages starts watching for new headers and processes them to get any new delayed messages
+within the safety tolerance of the rollup
+*/
+func (d *DelayedMessageFetcher) startWatchDelayedMessages(ctx context.Context) {
+	log.Info("Starting watch for new headers in delayed message fetcher")
+	// Subscibe to new headers
+
+	if !d.l1Reader.Started() {
+		// Start the l1 reader
+		d.l1Reader.Start(ctx)
+	}
+
+	newHeaders, unsubscribe := d.l1Reader.Subscribe(false)
+
+	d.LaunchThread(func(ctx context.Context) {
+		for {
+			select {
+			case <-ctx.Done():
+				log.Warn("context done in delayed message fetcher", "err", ctx.Err())
+				unsubscribe()
+				return
+
+			case header, ok := <-newHeaders:
+				if !ok {
+					log.Error("headerChan closed unexpectedly")
+				} else {
+					err := d.processNewHeader(ctx, header)
+					if err != nil {
+						log.Warn("could not process new header", "err", err, "header", header.Number.Uint64())
+					}
+				}
+			}
+		}
+	})
+}
+
+/*
+processNewHeader processes the new header to get any delayed messages
+*/
+func (d *DelayedMessageFetcher) processNewHeader(ctx context.Context, header *types.Header) error {
+	log.Debug("Processing new header in delayed message fetcher", "header", header.Number.Uint64())
+	var endBlock uint64
+	var err error
+	if endBlock, err = d.getL1BlockWithinSafetyTolerance(ctx, header); err != nil {
+		return err
+	}
+	if endBlock == 0 {
+		return nil
+	}
+
+	// Get the from block from the database
+	fromBlock := d.fromBlock
+	log.Debug("getting delayed messages in range", "fromBlock", fromBlock, "endBlock", endBlock)
+	err = d.getDelayedMessagesInRange(ctx, fromBlock, endBlock)
+	if err != nil {
+		log.Error("failed to get delayed messages in range", "err", err, "fromBlock", fromBlock, "endBlock", endBlock)
+		return err
+	}
+
+	return nil
+}
+
+func (d *DelayedMessageFetcher) processDelayedMessage(messageWithMetadataAndPos *espressostreamer.MessageWithMetadataAndPos) (*espressostreamer.MessageWithMetadataAndPos, uint64, error) {
+	delayedMessagesRead := messageWithMetadataAndPos.MessageWithMeta.DelayedMessagesRead
+
+	delayedCount := d.delayedCount
+	// If this is delayed message, we need to get the message from L1
+	// and replace the message in the messageWithMetadataAndPos
+	delayedMessageToProcess := delayedMessagesRead - 1
+
+	if delayedMessageToProcess > delayedCount {
+		log.Warn("delayed message fetcher is lagging behind", "delayedMessagesRead", delayedMessagesRead, "delayedCount", delayedCount)
+		return nil, 0, fmt.Errorf("delayed message fetcher is lagging behind")
+	}
+	log.Debug("Getting delayed message", "delayedCount", delayedMessageToProcess)
+
+	// Note: here we are using DelayedMessagesRead - 1 because that is the index of the delayed message
+	// that needs to be read
+	message, fromBlock, err := d.readDelayedMessageAndFromBlock(delayedMessageToProcess)
+	if err != nil {
+		log.Error("failed to get delayed message", "err", err)
+		return messageWithMetadataAndPos, 0, err
+	}
+	messageWithMetadataAndPos.MessageWithMeta.Message = message.Message
+
+	return messageWithMetadataAndPos, fromBlock, nil
+}
+
+/*
+Reads the delayed message from the database
+*/
+func (f *DelayedMessageFetcher) readDelayedMessageAndFromBlock(key uint64) (*DelayedInboxMessage, uint64, error) {
+	if _, ok := f.delayedMessages[key]; !ok {
+		return nil, 0, fmt.Errorf("delayed message not found")
+	}
+	delayedMessage := f.delayedMessages[key]
+	if _, ok := f.delayedMessagesFromBlock[key]; !ok {
+		return nil, 0, fmt.Errorf("delayed message from block not found")
+	}
+	delayedMessageFromBlock := f.delayedMessagesFromBlock[key]
+	return delayedMessage, delayedMessageFromBlock, nil
+}
+
+/*
+getL1BlockNumber returns the L1 block number based on the config.
+
+	if waitForFinalization == true:
+		return latest finalized block number
+	else if waitForConfirmations == true:
+		return latest block number - requiredBlockDepth
+	else:
+		return latest  block number
+*/
+func (d *DelayedMessageFetcher) getL1BlockNumber(ctx context.Context) (uint64, error) {
+
+	// If in setting we need to wait for finalized block, then get the latest finalized block number
+	if d.waitForFinalization {
+		return d.l1Reader.LatestFinalizedBlockNr(ctx)
+	} else if d.requiredBlockDepth > 0 {
+		// If we need to wait for confirmations,
+		// then get the latest block number - requiredBlockDepth
+		latestBlockNumber, err := d.l1Reader.Client().BlockNumber(ctx)
+		if err != nil {
+			return 0, err
+		}
+		if latestBlockNumber < d.requiredBlockDepth {
+			// chain is too young, start from genesis
+			return 0, nil
+		}
+		// Get the latest block - requiredBlockDepth
+		return latestBlockNumber - d.requiredBlockDepth, nil
+	}
+
+	// If no value is set, just use the latest block number
+	return d.l1Reader.Client().BlockNumber(ctx)
+}
+
+// getDelayedMessageLatestIndexAtBlock is a wrapper function for the delayedBridge.GetMessageCount function. This allows users of the DelayedMessageFetcher
+// to query for the message count at a block.
+func (f *DelayedMessageFetcher) getDelayedMessageLatestIndexAtBlock(blockNumber uint64) (uint64, error) {
+	count, err := f.delayedBridge.GetMessageCount(context.Background(), new(big.Int).SetUint64(blockNumber))
+	if err != nil {
+		return 0, err
+	}
+	return count, nil
+}
+
+/*
+getDelayedMessagedInRange fetches all the delayed messages in the range [startBlock, endBlock]
+and stores them in the database
+*/
+func (d *DelayedMessageFetcher) getDelayedMessagesInRange(ctx context.Context, fromBlock uint64, toBlock uint64) error {
+
+	// Fetching the sequencer batches is important so that we can later parse the batch and get the sequencer batch data to store in the database
+	log.Debug("Looking for batches in range", "from", fromBlock, "to", toBlock)
+	fromBlockBigInt := big.NewInt(0).SetUint64(fromBlock)
+	toBlockBigInt := big.NewInt(0).SetUint64(toBlock)
+
+	sequencerBatches, err := d.sequencerInbox.LookupBatchesInRange(ctx, fromBlockBigInt, toBlockBigInt)
+	if err != nil {
+		return err
+	}
+	log.Debug("Sequencer batches found", "sequencerBatches", sequencerBatches)
+
+	log.Debug("Looking for delayed messages from range", "from", fromBlock, "to", toBlock)
+	msgs, err := d.delayedBridge.LookupMessagesInRange(ctx, big.NewInt(0).SetUint64(fromBlock), big.NewInt(0).SetUint64(toBlock), func(batchNum uint64) ([]byte, error) {
+		if len(sequencerBatches) > 0 && batchNum >= sequencerBatches[0].SequenceNumber {
+			idx := batchNum - sequencerBatches[0].SequenceNumber
+			if idx < uint64(len(sequencerBatches)) {
+				return sequencerBatches[idx].Serialize(ctx, d.l1Reader.Client())
+			}
+			return nil, fmt.Errorf("failed to get sequencer batch data: %w", err)
+		}
+
+		return nil, fmt.Errorf("failed to get sequencer batch data: %w", err)
+	})
+	if err != nil {
+		log.Error("Failed to lookup delayed messages", "err", err)
+		return err
+	}
+
+	sort.Slice(msgs, func(i, j int) bool {
+		seqNumI, err := msgs[i].Message.Header.SeqNum()
+		if err != nil {
+			return false
+		}
+		seqNumJ, err := msgs[j].Message.Header.SeqNum()
+		if err != nil {
+			return false
+		}
+		return seqNumI < seqNumJ
+	})
+
+	log.Debug("sequencer delayed messages found", "delayedMessages", msgs)
+
+	lastDelayedMessageIndex := d.delayedCount
+
+	for _, msg := range msgs {
+		seqNum, err := msg.Message.Header.SeqNum()
+		if err != nil {
+			return err
+		}
+		log.Info("Caff node: processing delayed message", "seqNum", seqNum)
+		if seqNum == 0 {
+			// init message
+			log.Debug("caff node: skip storing init message")
+			continue
+		}
+
+		if seqNum <= lastDelayedMessageIndex {
+			log.Warn("Caff node already has processed delayed message", "seqNum", seqNum, "lastDelayedMessageIndex", lastDelayedMessageIndex)
+			continue
+		}
+
+		if seqNum > lastDelayedMessageIndex+1 {
+			// Delayed message fetcher expects to fetch messages strictly in order. If a missing message is detected here,
+			// it indicates a break in sequential fetching. Recovery is not handled by this fetcher and would require additional logic.
+			err := fmt.Errorf("caff node is missing a delayed message with seqNum: %d, lastDelayedMessageIndex: %d", seqNum, lastDelayedMessageIndex)
+			log.Error(err.Error())
+			d.fatalErrChan <- err
+			return err
+		}
+
+		lastDelayedMessageIndex++
+
+		d.delayedMessages[lastDelayedMessageIndex] = msg
+		d.delayedMessagesFromBlock[lastDelayedMessageIndex] = fromBlock
+		d.delayedCount += 1
+	}
+
+	// Store the from block in the database
+	d.fromBlock = toBlock + 1
+
+	return nil
+}
+
+/*
+getL1BlockWithinSafetyTolerance checks if the L1 block is within the safety tolerance of the rollup
+  - if we need to wait for finalized block, then it returns the latest finalized block number
+  - if we need to wait for confirmations, then it returns the latest block number - requiredBlockDepth
+  - else - it returns the latest header
+*/
+func (d *DelayedMessageFetcher) getL1BlockWithinSafetyTolerance(ctx context.Context, header *types.Header) (uint64, error) {
+	fromBlock := d.fromBlock
+	// If we have already processed this header, we can skip it
+	if header.Number.Uint64() < fromBlock {
+		log.Warn("L1 block number is less than from block", "l1Block", header.Number.Uint64(), "fromBlock", fromBlock)
+		return 0, nil
+	}
+	if d.waitForFinalization {
+		// if we have configured to wait for finalizations, fetch the latest finalized block number.
+		blockNumber, err := d.l1Reader.LatestFinalizedBlockNr(ctx)
+		if err != nil {
+			return 0, fmt.Errorf("error getting finalized block header to check safety tolerance of delayed message: %w", err)
+		}
+
+		if blockNumber < fromBlock {
+			log.Warn("finalized block has already been processed", "current finalized block number", blockNumber, "fromBlock", fromBlock)
+			return 0, nil
+		}
+		return blockNumber, nil
+	} else if d.requiredBlockDepth > 0 {
+		// Get the block number which is latest header - requiredBlockDepth
+		if header.Number.Uint64()-d.requiredBlockDepth < fromBlock {
+			return 0, fmt.Errorf("block already processed current block number: %v, fromBlock: %v", header.Number.Uint64()-d.requiredBlockDepth, fromBlock)
+		}
+		return header.Number.Uint64() - d.requiredBlockDepth, nil
+	}
+	return header.Number.Uint64(), nil
+}
+
+// storeDelayedMessageLatestIndex stores the delayed message index in the database
+func (d *DelayedMessageFetcher) storeDelayedMessageLatestIndex(count uint64) {
+	d.delayedCount = count
+}
+
+func NewDelayedMessageFetcher(
+	delayedBridge *DelayedBridge,
+	l1Reader *headerreader.HeaderReader,
+	waitForFinalization bool,
+	requiredBlockDepth uint64,
+	fromBlock uint64,
+	sequencerInbox *SequencerInbox,
+	fatalErrChan chan error,
+) *DelayedMessageFetcher {
+	return &DelayedMessageFetcher{
+		fromBlock:                fromBlock,
+		delayedBridge:            delayedBridge,
+		l1Reader:                 l1Reader,
+		waitForFinalization:      waitForFinalization,
+		requiredBlockDepth:       requiredBlockDepth,
+		sequencerInbox:           sequencerInbox,
+		fatalErrChan:             fatalErrChan,
+		delayedMessages:          make(map[uint64]*DelayedInboxMessage),
+		delayedMessagesFromBlock: make(map[uint64]uint64),
+	}
+}
+
+func (d *DelayedMessageFetcher) Start(ctx context.Context) bool {
+	log.Info("Starting delayed message fetcher")
+	d.StopWaiter.Start(ctx, d)
+	// Delayed message fetcher doesnt start until it has backfilled all the messages
+	// till a `matureBlock` which is within the saferty tolerance of the rollup
+	err := d.backfill(ctx)
+	if err != nil {
+		log.Error("delayed message fetcher backfill failed", "err", err)
+		return false
+	}
+	d.startWatchDelayedMessages(ctx)
+	return true
+}
+
+func (d *DelayedMessageFetcher) StopAndWait() {
+	d.StopWaiter.StopAndWait()
+}
diff --git a/arbnode/espresso_force_inclusion_checker.go b/arbnode/espresso_force_inclusion_checker.go
new file mode 100644
index 00000000000..d9798835e64
--- /dev/null
+++ b/arbnode/espresso_force_inclusion_checker.go
@@ -0,0 +1,260 @@
+package arbnode
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math/big"
+	"time"
+
+	flag "github.com/spf13/pflag"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
+	"github.com/offchainlabs/nitro/solgen/go/node_interfacegen"
+	"github.com/offchainlabs/nitro/util/arbmath"
+	"github.com/offchainlabs/nitro/util/headerreader"
+	"github.com/offchainlabs/nitro/util/stopwaiter"
+)
+
+var (
+	ForceInclusionErr = errors.New("force inclusion is going to happen")
+)
+
+type ForceInclusionCheckerConfig struct {
+	RetryTime                time.Duration `koanf:"retry-time"`
+	PollingInterval          time.Duration `koanf:"polling-interval"`
+	BlockThresholdTolerance  uint64        `koanf:"block-threshold-tolerance"`
+	SecondThresholdTolerance uint64        `koanf:"second-threshold-tolerance"`
+
+	ErrorToleranceDuration time.Duration `koanf:"error-tolerance-duration"`
+}
+
+var DefaultEspressoForceInclusionCheckerConfig = ForceInclusionCheckerConfig{
+	RetryTime:       time.Second * 2,
+	PollingInterval: time.Minute * 8,
+	// Default maxTimeVariationDelayBlocks=5760 in the contract (eth blocks produced in 24 hours)
+	// We are setting the default value to 20 hours for buffer so we need to set (5760 - 4800) blocks which is
+	// 960 blocks
+	BlockThresholdTolerance: 960,
+	//  Default is maxTimeVariationDelaySeconds=86400 (24 hour in seconds)
+	// We are setting the default value to 20 hours for buffer
+	// in the contract so we need to set (86400 - 72000) seconds which is 14,400 seconds
+	SecondThresholdTolerance: 14400,
+	ErrorToleranceDuration:   time.Minute * 8,
+}
+
+func EspressoForceInclusionConfigAddOptions(prefix string, f *flag.FlagSet) {
+	f.Duration(prefix+".retry-time", DefaultEspressoForceInclusionCheckerConfig.RetryTime, "retry time after a failure")
+	f.Duration(prefix+".polling-interval", DefaultEspressoForceInclusionCheckerConfig.PollingInterval, "time after a success")
+	f.Uint64(prefix+".block-threshold-tolerance", DefaultEspressoForceInclusionCheckerConfig.BlockThresholdTolerance, "block threshold tolerance for ETH L1")
+	f.Uint64(prefix+".second-threshold-tolerance", DefaultEspressoForceInclusionCheckerConfig.SecondThresholdTolerance, "second threshold tolerance for ETH L1")
+	f.Duration(prefix+".error-tolerance-duration", DefaultEspressoForceInclusionCheckerConfig.ErrorToleranceDuration, "error tolerance duration")
+}
+
+// SeqInboxInterface defines an interface for interacting with the sequencer inbox contract.
+// Note: When `deployBold` is disabled, the [MaxTimeVariation](arbnode/espresso_force_inclusion_checker.go:14:1-14:78) values are hardcoded,
+// which makes this interface difficult to mock in tests.
+type SeqInboxInterface interface {
+	MaxTimeVariation(context.Context) (*big.Int, *big.Int, *big.Int, *big.Int, error)
+	TotalDelayedMessagesRead(context.Context) (*big.Int, error)
+}
+
+type SeqInbox struct {
+	seqInbox *bridgegen.SequencerInbox
+}
+
+func (s *SeqInbox) MaxTimeVariation(ctx context.Context) (*big.Int, *big.Int, *big.Int, *big.Int, error) {
+	return s.seqInbox.MaxTimeVariation(&bind.CallOpts{Context: ctx})
+}
+
+func (s *SeqInbox) TotalDelayedMessagesRead(ctx context.Context) (*big.Int, error) {
+	return s.seqInbox.TotalDelayedMessagesRead(&bind.CallOpts{Context: ctx})
+}
+
+type ForceInclusionChecker struct {
+	stopwaiter.StopWaiter
+
+	seqInbox              SeqInboxInterface
+	config                ForceInclusionCheckerConfig
+	l1Reader              *headerreader.HeaderReader
+	delayedMessageFetcher *DelayedMessageFetcher
+	fatalErrChan          chan error
+}
+
+func NewForceInclusionChecker(
+	seqInbox SeqInboxInterface,
+	config ForceInclusionCheckerConfig,
+	l1Reader *headerreader.HeaderReader,
+	delayedMessageFetcher *DelayedMessageFetcher,
+	fatalErrChan chan error,
+) *ForceInclusionChecker {
+	return &ForceInclusionChecker{
+		seqInbox:              seqInbox,
+		config:                config,
+		l1Reader:              l1Reader,
+		delayedMessageFetcher: delayedMessageFetcher,
+		fatalErrChan:          fatalErrChan,
+	}
+}
+
+func (f *ForceInclusionChecker) checkIfMessageCanBeForceIncluded(ctx context.Context) error {
+	// Get the total number of delayed messages read in the sequencer inbox
+	totalDelayedMessagesRead, err := f.seqInbox.TotalDelayedMessagesRead(ctx)
+	if err != nil {
+		return fmt.Errorf("error getting total delayed messages read: %w", err)
+	}
+	log.Debug("Total delayed messages read", "totalDelayedMessagesRead", totalDelayedMessagesRead)
+
+	// Get the earliest block number that is without the force inclusion tolerance
+	badBlockNumber, err := f.getForceInclusionToleranceBlockNumber(ctx)
+	if err != nil {
+		return fmt.Errorf("error getting force inclusion tolerance block number: %w", err)
+	}
+	log.Debug("Force inclusion tolerance bad block number", "blockNumber", badBlockNumber)
+	// Check the delayed message count at this block number
+	count, err := f.delayedMessageFetcher.getDelayedMessageLatestIndexAtBlock(badBlockNumber)
+	if err != nil {
+		return fmt.Errorf("error getting delayed message count at block %d: %w", badBlockNumber, err)
+	}
+	log.Debug("Delayed message count at block", "count", count, "blockNumber", badBlockNumber)
+	// If the message count in delay inbox is less than or equal to the total delayed messages read
+	// then no force inclusion is going to happen.
+	if count <= arbmath.BigToUintSaturating(totalDelayedMessagesRead) {
+		log.Debug("force inclusion wont happen")
+		return nil
+	}
+	log.Debug("Force inclusion is going to happen")
+	// Force inclusion is going to happen, panic the node.
+	return ForceInclusionErr
+}
+
+func (f *ForceInclusionChecker) Start(ctx context.Context) error {
+	f.StopWaiter.Start(ctx, f)
+	var firstErrFound time.Time
+
+	return f.CallIterativelySafe(func(ctx context.Context) time.Duration {
+		err := f.checkIfMessageCanBeForceIncluded(ctx)
+		if err == nil {
+			firstErrFound = time.Time{}
+			return f.config.PollingInterval
+		}
+		if errors.Is(err, ForceInclusionErr) {
+			log.Error("force inclusion error", "err", err)
+			f.fatalErrChan <- err
+			return 0
+		}
+		if firstErrFound.IsZero() {
+			firstErrFound = time.Now()
+		} else if time.Since(firstErrFound) > f.config.ErrorToleranceDuration {
+			log.Error("error tolerance duration exceeded", "firstErrFound", firstErrFound, "timeSinceFirstErrFound", time.Since(firstErrFound))
+			f.fatalErrChan <- err
+		}
+		log.Error("error checking force inclusion", "err", err)
+		return f.config.RetryTime
+	})
+}
+
+func (f *ForceInclusionChecker) getForceInclusionToleranceBlockNumber(ctx context.Context) (uint64, error) {
+	maxTimeVariationDelayBlocks, _, maxTimeVariationDelaySeconds, _, err := f.seqInbox.MaxTimeVariation(ctx)
+	if err != nil {
+		return 0, err
+	}
+	log.Debug("Max time variation delay blocks", "maxTimeVariationDelayBlocks", maxTimeVariationDelayBlocks, "maxTimeVariationDelaySeconds", maxTimeVariationDelaySeconds)
+
+	parentLatestHeader, err := f.l1Reader.LastHeader(ctx)
+	if err != nil {
+		return 0, err
+	}
+
+	l1BlockNumber := parentLatestHeader.Number.Uint64()
+	l1TimeStamp := parentLatestHeader.Time
+
+	log.Debug("L1 block number", "l1BlockNumber", l1BlockNumber, "l1TimeStamp", l1TimeStamp)
+
+	if f.l1Reader.IsParentChainArbitrum() {
+		headerInfo := types.DeserializeHeaderExtraInformation(parentLatestHeader)
+		l1BlockNumber = headerInfo.L1BlockNumber
+	}
+
+	lastBadBlockNumber := arbmath.SaturatingUSub(f.config.BlockThresholdTolerance+l1BlockNumber, arbmath.BigToUintSaturating(maxTimeVariationDelayBlocks))
+	lastBadBlockTime := arbmath.SaturatingUSub(f.config.SecondThresholdTolerance+l1TimeStamp, arbmath.BigToUintSaturating(maxTimeVariationDelaySeconds))
+
+	log.Debug("Last bad block number", "lastBadBlockNumber", lastBadBlockNumber, "lastBadBlockTime", lastBadBlockTime)
+
+	if f.l1Reader.IsParentChainArbitrum() {
+		n, err := node_interfacegen.NewNodeInterface(types.NodeInterfaceAddress, f.l1Reader.Client())
+		if err != nil {
+			return 0, err
+		}
+		rng, err := n.L2BlockRangeForL1(&bind.CallOpts{Context: ctx}, lastBadBlockNumber)
+		if err == nil {
+			lastBadBlockNumber = rng.LastBlock
+			log.Debug("Last bad block number from L2 block range for L1", "lastBadBlockNumber", lastBadBlockNumber)
+		} else {
+			// If the L2 block range for L1 call fails, we will use binary search
+			// The start block number should be the genesis block
+			// Reference: https://github.com/OffchainLabs/arbitrum-sdk/blob/792a7ee3ccf09842653bc49b771671706894cbb4/src/lib/inbox/inbox.ts#L104-L113
+			genesis, err := n.NitroGenesisBlock(&bind.CallOpts{Context: ctx})
+			if err != nil {
+				return 0, err
+			}
+			target := lastBadBlockNumber
+			start := genesis.Uint64()
+			end := parentLatestHeader.Number.Uint64()
+			lastBadBlockNumber, err = binarySearchForBlockNumber(ctx, start, end, func(ctx context.Context, blockNumber uint64) (int, error) {
+				header, err := f.l1Reader.Client().HeaderByNumber(ctx, arbmath.UintToBig(blockNumber))
+				if err != nil {
+					return 0, err
+				}
+				l1Block := types.DeserializeHeaderExtraInformation(header).L1BlockNumber
+				if l1Block < target {
+					return binarySearch_LessThanTarget, nil
+				} else if l1Block > target {
+					return binarySearch_GreaterThanTarget, nil
+				} else {
+					return binarySearch_EqualToTarget, nil
+				}
+			})
+			if err != nil {
+				log.Error("error in binary search", "err", err)
+				return 0, err
+			}
+			log.Debug("Last bad block number from binary search", "lastBadBlockNumber", lastBadBlockNumber)
+		}
+	}
+
+	lastBadBlock, err := f.findFirstParentChainBlockBelow(ctx, lastBadBlockNumber, lastBadBlockTime)
+	if err != nil {
+		log.Error("error finding first parent chain block below", "err", err)
+		return 0, err
+	}
+	return lastBadBlock, nil
+}
+
+func (f *ForceInclusionChecker) findFirstParentChainBlockBelow(ctx context.Context, lastBadBlockNumber uint64, lastBadBlockTime uint64) (uint64, error) {
+	client := f.l1Reader.Client()
+	blockNumber := lastBadBlockNumber
+
+	for blockNumber > 0 {
+		header, err := client.HeaderByNumber(ctx, arbmath.UintToBig(blockNumber))
+		if err != nil {
+			log.Error("Error getting block", "blockNumber", blockNumber, "err", err)
+			return 0, err
+		}
+		if header.Number.Uint64() <= lastBadBlockNumber || header.Time <= lastBadBlockTime {
+			log.Debug("Block number is less than or equal to last bad block number or time", "blockNumber", blockNumber, "lastBadBlockNumber", lastBadBlockNumber, "lastBadBlockTime", lastBadBlockTime)
+			return blockNumber, nil
+		}
+		log.Debug("Block number Decreasing", "blockNumber", blockNumber)
+		blockNumber--
+	}
+	return 0, fmt.Errorf("no parent block found")
+}
+
+func (f *ForceInclusionChecker) StopAndWait() {
+	f.StopWaiter.StopAndWait()
+}
diff --git a/arbnode/espresso_snapshot_handler.go b/arbnode/espresso_snapshot_handler.go
new file mode 100644
index 00000000000..9062d646d55
--- /dev/null
+++ b/arbnode/espresso_snapshot_handler.go
@@ -0,0 +1,132 @@
+package arbnode
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/offchainlabs/nitro/arbutil"
+	"github.com/offchainlabs/nitro/espresso/authdb"
+	espresso_key_manager "github.com/offchainlabs/nitro/espresso/key-manager"
+	"github.com/offchainlabs/nitro/util/stopwaiter"
+)
+
+type EspressoSnapshotHandler struct {
+	stopwaiter.StopWaiter
+	db               *authdb.AuthDB
+	parentChainDir   string
+	l2chainDataDir   string
+	initializeTags   bool
+	generateSnapshot bool
+	keyManager       *espresso_key_manager.EspressoKeyManager
+	batchSize        int
+}
+
+func NewEspressoSnapshotHandler(db *authdb.AuthDB, parentChainDir string, l2chainDataDir string, initializeTags bool, keyManager *espresso_key_manager.EspressoKeyManager, generateSnapshot bool, batchSize int) *EspressoSnapshotHandler {
+	return &EspressoSnapshotHandler{
+		db:               db,
+		parentChainDir:   parentChainDir,
+		l2chainDataDir:   l2chainDataDir,
+		initializeTags:   initializeTags,
+		keyManager:       keyManager,
+		generateSnapshot: generateSnapshot,
+		batchSize:        batchSize,
+	}
+}
+
+func (s *EspressoSnapshotHandler) StoreSnapshotSha256(sum string) error {
+	path := filepath.Join(s.parentChainDir, "snapshot.txt")
+	file, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("failed to create snapshot file: %w", err)
+	}
+	defer file.Close()
+	_, err = file.WriteString(sum)
+	if err != nil {
+		return fmt.Errorf("failed to write snapshot file: %w", err)
+	}
+	log.Info("Stored the snapshot hash in a file", "sha256_h1", sum, "path", path)
+	return nil
+}
+
+func (s *EspressoSnapshotHandler) StoreSnapshotSignature(signature []byte) error {
+	path := filepath.Join(s.parentChainDir, "snapshot_signature.txt")
+	file, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("failed to create snapshot file: %w", err)
+	}
+	defer file.Close()
+	_, err = file.Write(signature)
+	if err != nil {
+		return fmt.Errorf("failed to write snapshot file: %w", err)
+	}
+	log.Info("Stored the snapshot signature in a file", "path", path)
+	return nil
+}
+
+func (s *EspressoSnapshotHandler) Start(ctx context.Context) error {
+	s.StopWaiter.Start(ctx, s)
+	if !s.initializeTags {
+		log.Warn("Initialization of auth tags is disabled, skipping")
+		return nil
+	}
+
+	// Only if snapshot mode is enabled, we re-initialize the tags
+	err := s.db.InitAuthTagsDatabase(s.batchSize)
+	if err != nil {
+		return fmt.Errorf("failed to add auth tags to the database: %w", err)
+	}
+
+	// #nosec G115 -- batchSize is guaranteed non-negative
+	err = s.db.InitAncientAuthTags(uint64(s.batchSize))
+	if err != nil {
+		return fmt.Errorf("failed to add ancient auth tags: %w", err)
+	}
+
+	return nil
+}
+
+func (s *EspressoSnapshotHandler) CreateAndSnapshot() error {
+	sha256Hash, err := arbutil.HashDirParallel(s.l2chainDataDir)
+	if err != nil {
+		return err
+	}
+	log.Info("Hashed the l2chaindata dir", "sha256_h1", sha256Hash)
+	// Store the sha256 hash of the snapshot
+	err = s.StoreSnapshotSha256(sha256Hash)
+	if err != nil {
+		return err
+	}
+	if s.keyManager != nil {
+		signedBytes, err := s.keyManager.SignMessage([]byte(sha256Hash))
+		if err != nil {
+			return fmt.Errorf("failed to sign the snapshot hash: %w", err)
+		}
+		err = s.StoreSnapshotSignature(signedBytes)
+		if err != nil {
+			return fmt.Errorf("failed to store snapshot signature: %w", err)
+		}
+		log.Info("Signed the snapshot hash using the key manager")
+	}
+
+	return nil
+}
+
+func (s *EspressoSnapshotHandler) StopAndWait() {
+	s.StopWaiter.StopAndWait()
+	// Close the database before creating the snapshot
+	s.db.Close()
+	if !s.generateSnapshot {
+		log.Info("Snapshot generation is disabled, skipping")
+		return
+	}
+	log.Info("Taking snapshot of the database, this may take a while")
+	err := s.CreateAndSnapshot()
+	if err != nil {
+		log.Error("Failed to create snapshot", "err", err)
+	}
+	log.Info("Snapshot taken and stored")
+}
diff --git a/arbnode/espresso_state_checker.go b/arbnode/espresso_state_checker.go
new file mode 100644
index 00000000000..e8ad54dcd8a
--- /dev/null
+++ b/arbnode/espresso_state_checker.go
@@ -0,0 +1,149 @@
+package arbnode
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	flag "github.com/spf13/pflag"
+
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/offchainlabs/nitro/util/stopwaiter"
+)
+
+var (
+	StateUnmatchedErr = errors.New("state unmatched")
+)
+
+type StateCheckerConfig struct {
+	PollingInterval        time.Duration `koanf:"polling-interval"`
+	ErrorToleranceDuration time.Duration `koanf:"error-tolerance-duration"`
+
+	// http endpoint of the trusted node
+	TrustedNodeUrl string `koanf:"trusted-node-url"`
+}
+
+var DefaultStateCheckerConfig = StateCheckerConfig{
+	PollingInterval:        time.Second * 100,
+	ErrorToleranceDuration: time.Minute * 10,
+}
+
+func EspressoStateCheckerConfigAddOptions(prefix string, f *flag.FlagSet) {
+	f.Duration(prefix+".polling-interval", DefaultStateCheckerConfig.PollingInterval, "time after a success")
+	f.Duration(prefix+".error-tolerance-duration", DefaultStateCheckerConfig.ErrorToleranceDuration, "error tolerance duration")
+	f.String(prefix+".trusted-node-url", DefaultStateCheckerConfig.TrustedNodeUrl, "http endpoint of the trusted node")
+}
+
+type StateChecker struct {
+	stopwaiter.StopWaiter
+
+	config       StateCheckerConfig
+	fatalErrChan chan error
+
+	trustedClient *ethclient.Client
+	myClient      *ethclient.Client
+}
+
+func NewStateChecker(
+	config StateCheckerConfig,
+	httpPort int,
+	fatalErrChan chan error,
+) *StateChecker {
+	if config.TrustedNodeUrl == "" {
+		log.Warn("trusted node url is empty, state checker will not start")
+		return nil
+	}
+
+	client, err := ethclient.DialContext(context.Background(), config.TrustedNodeUrl)
+	if err != nil {
+		panic(err)
+	}
+	myUrl := fmt.Sprintf("http://localhost:%d", httpPort)
+	myClient, err := ethclient.DialContext(context.Background(), myUrl)
+	if err != nil {
+		log.Warn("failed to dial my node for state checker, state checker will not start", "err", err)
+		return nil
+	}
+
+	return &StateChecker{
+		config:        config,
+		fatalErrChan:  fatalErrChan,
+		myClient:      myClient,
+		trustedClient: client,
+	}
+}
+
+func (s *StateChecker) Start(ctx context.Context) error {
+	s.StopWaiter.Start(ctx, s)
+
+	return s.StartMonitoring(ctx)
+}
+
+func (s *StateChecker) StartMonitoring(ctx context.Context) error {
+	var firstErrFound time.Time
+	return s.CallIterativelySafe(func(ctx context.Context) time.Duration {
+		err := s.checkState(ctx)
+		if err == nil {
+			firstErrFound = time.Time{}
+			return s.config.PollingInterval
+		}
+		if strings.Contains(err.Error(), StateUnmatchedErr.Error()) {
+			log.Error("shutting down due to state unmatched", "err", err)
+			s.fatalErrChan <- err
+			return 0
+		}
+		if firstErrFound.IsZero() {
+			firstErrFound = time.Now()
+		} else if time.Since(firstErrFound) > s.config.ErrorToleranceDuration {
+			log.Error("shutting down due to error tolerance duration exceeded", "err", err)
+			s.fatalErrChan <- err
+		} else if strings.Contains(err.Error(), "connection refused") && strings.Contains(err.Error(), "my node") {
+			// This case is for the situation where the node haven't started yet
+			// returns zero to make sure the state checker checks the state first
+			// before the caff node consuming any messages.
+			//
+			// And if this error lasts for too long, the state checker will shut down
+			log.Error("error checking state", "err", err)
+			return 0
+		}
+
+		log.Error("error checking state", "err", err)
+		return s.config.PollingInterval
+	})
+}
+
+func (s *StateChecker) checkState(ctx context.Context) error {
+	block, err := s.trustedClient.BlockByNumber(ctx, nil)
+	if err != nil {
+		return fmt.Errorf("failed to get latest block through trusted node: %w", err)
+	}
+	blockNumber := block.Number()
+	myLatestBlock, err := s.myClient.BlockByNumber(ctx, nil)
+	if err != nil {
+		return fmt.Errorf("failed to get latest block through my node: %w", err)
+	}
+	myLatestBlockNumber := myLatestBlock.Number()
+
+	if myLatestBlockNumber.Cmp(blockNumber) < 0 {
+		log.Info("my node is behind the trusted node", "myBlockNumber", myLatestBlockNumber, "trustedBlockNumber", blockNumber)
+		block, err = s.trustedClient.BlockByNumber(ctx, myLatestBlockNumber)
+		if err != nil {
+			return fmt.Errorf("failed to get block by number through trusted node: %w", err)
+		}
+		blockNumber = myLatestBlockNumber
+	}
+	myBlock, err := s.myClient.BlockByNumber(ctx, blockNumber)
+	if err != nil {
+		return fmt.Errorf("failed to get block by number through my node: %w", err)
+	}
+
+	if block.Hash() != myBlock.Hash() {
+		err := fmt.Errorf("%s: trusted node: %s, my node: %s", StateUnmatchedErr.Error(), block.Hash(), myBlock.Hash())
+		return err
+	}
+	return nil
+}
diff --git a/arbnode/espresso_transaction_streamer_helpers.go b/arbnode/espresso_transaction_streamer_helpers.go
new file mode 100644
index 00000000000..bd1f64957a8
--- /dev/null
+++ b/arbnode/espresso_transaction_streamer_helpers.go
@@ -0,0 +1,212 @@
+package arbnode
+
+// This file contains a few helper functions to help interoperate with the
+// TransactionStreamer and the Espresso code.
+//
+// These functions are used for testing and configuration purposes, and are
+// not intended to general common usage.
+
+import (
+	"math/big"
+	"time"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+	espresso_light_client "github.com/EspressoSystems/espresso-network/sdks/go/light-client"
+
+	key_manager "github.com/offchainlabs/nitro/espresso/key-manager"
+	"github.com/offchainlabs/nitro/espresso/submitter"
+)
+
+// TransactionStreamerEspressoConfig is a configuration struct for the
+// TransactionStreamer that contains fields specific to our Espresso integration
+// efforts.
+type TransactionStreamerEspressoConfig struct {
+	EspressoClient                        espresso_client.EspressoClient
+	LightClientReader                     espresso_light_client.LightClientReaderInterface
+	KeyManager                            key_manager.EspressoKeyManagerInterface
+	TxnsMonitoringInterval                time.Duration
+	ResubmitEspressoTxDeadline            time.Duration
+	EscapeHatchEnabled                    bool
+	MaxTransactionSize                    int64
+	InitialFinalizedSequencerMessageCount *big.Int
+
+	SubmitterCreator       func(options ...submitter.EspressoSubmitterConfigOption) (submitter.EspressoSubmitter, error)
+	SubmitterConfiguration []submitter.EspressoSubmitterConfigOption
+}
+
+// TransactionStreamerEspressoOption is a functional option type for configuring
+// the TransactionStreamerEspressoConfig.
+type TransactionStreamerEspressoOption func(*TransactionStreamerEspressoConfig)
+
+// WithEspressoClient is a functional option to set the Espresso client in the
+// TransactionStreamerEspressoConfig.
+func WithEspressoClient(espressoClient espresso_client.EspressoClient) TransactionStreamerEspressoOption {
+	return func(config *TransactionStreamerEspressoConfig) {
+		config.EspressoClient = espressoClient
+	}
+}
+
+// WithLightClientReader is a functional option to set the LightClientReader
+// in the TransactionStreamerEspressoConfig.
+func WithLightClientReader(lightClientReader espresso_light_client.LightClientReaderInterface) TransactionStreamerEspressoOption {
+	return func(config *TransactionStreamerEspressoConfig) {
+		config.LightClientReader = lightClientReader
+	}
+}
+
+// WithKeyManager is a functional option to set the EspressoKeyManagerInterface
+// in the TransactionStreamerEspressoConfig.
+func WithKeyManager(keyManager key_manager.EspressoKeyManagerInterface) TransactionStreamerEspressoOption {
+	return func(config *TransactionStreamerEspressoConfig) {
+		config.KeyManager = keyManager
+	}
+}
+
+// WithMaxTransactionSize is a functional option to set the maximum transaction
+// size in the TransactionStreamerEspressoConfig.
+func WithEscapeHatchEnabled(enable bool) TransactionStreamerEspressoOption {
+	return func(config *TransactionStreamerEspressoConfig) {
+		config.EscapeHatchEnabled = enable
+	}
+}
+
+// WithMaxBlockLagBeforeEscapeHatch is a functional option to set the maximum
+// block lag before the escape hatch is triggered in the
+// TransactionStreamerEspressoConfig.
+func WithMaxTransactionSize(size int64) TransactionStreamerEspressoOption {
+	return func(config *TransactionStreamerEspressoConfig) {
+		config.MaxTransactionSize = size
+	}
+}
+
+// WithResubmitEspressoTxDeadline is a functional option to set the deadline for
+// resubmitting Espresso transactions in the TransactionStreamerEspressoConfig.
+func WithResubmitEspressoTxDeadline(deadline time.Duration) TransactionStreamerEspressoOption {
+	return func(config *TransactionStreamerEspressoConfig) {
+		config.ResubmitEspressoTxDeadline = deadline
+	}
+}
+
+// WithInitialFinalizedSequencerMessageCount is a functional option to set the
+// initial finalized sequencer message count in the TransactionStreamerEspressoConfig.
+func WithInitialFinalizedSequencerMessageCount(count *big.Int) TransactionStreamerEspressoOption {
+	return func(config *TransactionStreamerEspressoConfig) {
+		config.InitialFinalizedSequencerMessageCount = count
+	}
+}
+
+// WithSubmitterCreator is a functional option that allows for setting a custom
+// submitter creator function in the TransactionStreamerEspressoConfig. This
+// function is responsible for creating an EspressoSubmitter instance with the
+// provided configuration options.
+func WithSubmitterCreator(
+	creator func(options ...submitter.EspressoSubmitterConfigOption) (submitter.EspressoSubmitter, error),
+) TransactionStreamerEspressoOption {
+	return func(config *TransactionStreamerEspressoConfig) {
+		config.SubmitterCreator = creator
+	}
+}
+
+// AddSubmitterConfigurationOptions is a functional option that allows for
+// adding multiple EspressoSubmitterConfigOptions to the
+// TransactionStreamerEspressoConfig.
+func AddSubmitterConfigurationOptions(
+	options ...submitter.EspressoSubmitterConfigOption,
+) TransactionStreamerEspressoOption {
+	return func(config *TransactionStreamerEspressoConfig) {
+		config.SubmitterConfiguration = append(config.SubmitterConfiguration, options...)
+	}
+}
+
+// WithMultipleEspressoOptions is a functional option that allows for multiple
+// TransactionStreamerEspressoOptions to be applied at once. This is useful for
+// configuring the TransactionStreamer with multiple options in a single call.
+func WithMultipleEspressoOptions(options ...TransactionStreamerEspressoOption) TransactionStreamerEspressoOption {
+	return func(config *TransactionStreamerEspressoConfig) {
+		applyEspressoOptions(config, options...)
+	}
+}
+
+// WithTransactionStreamer is an `EspressoSubmitterConfig` option that
+// configures the `EspressoSubmitter` with information provided by the
+// given `TransactionStreamer`.
+//
+// NOTE: This is defined here to avoid circular dependencies between
+// `arbnode/espresso/submitter` and `arbnode`
+func WithTransactionStreamer(
+	streamer *TransactionStreamer,
+) func(config *submitter.EspressoSubmitterConfig) {
+	config := streamer.config()
+	return submitter.WithMultipleOptions(
+		submitter.WithMessageGetter(streamer),
+		submitter.WithChainID(streamer.chainConfig.ChainID.Uint64()),
+		submitter.WithDatabase(streamer.db),
+		submitter.WithAttestationFiles(config.UserDataAttestationFile, config.QuoteFile),
+	)
+}
+
+// applyEspressoOptions is a helper function that applies the provided options
+// to the TransactionStreamerEspressoConfig.
+func applyEspressoOptions(
+	config *TransactionStreamerEspressoConfig,
+	options ...TransactionStreamerEspressoOption,
+) {
+	for _, option := range options {
+		option(config)
+	}
+}
+
+// ConfigureEspressoFields is a function that configures the Espresso fields
+// in the TransactionStreamer with the provided options.
+//
+// Since many of the Espresso fields are optional, this function allows for
+// flexible modification of the TransactionStreamer configuration
+// without hardcoding values in the TransactionStreamer implementation.
+//
+// This is useful, and even necessary, for testing purposes, as it allows
+// for easy configuration of the TransactionStreamer with various Espresso
+// fields that would otherwise be impossible to set without
+// modifying the TransactionStreamer implementation itself.
+func ConfigureEspressoFields(
+	streamer *TransactionStreamer,
+	options ...TransactionStreamerEspressoOption,
+) (submitter.EspressoSubmitter, error) {
+	config := TransactionStreamerEspressoConfig{
+		InitialFinalizedSequencerMessageCount: big.NewInt(0),
+		MaxTransactionSize:                    EspressoTxSizeLimit,
+		TxnsMonitoringInterval:                DefaultEspressoBatchPosterConfig.TxnsMonitoringInterval,
+		SubmitterCreator:                      submitter.NewPollingEspressoSubmitter,
+		ResubmitEspressoTxDeadline:            DefaultEspressoBatchPosterConfig.ResubmitEspressoTxDeadline,
+	}
+
+	applyEspressoOptions(&config, options...)
+
+	if config.SubmitterCreator == nil {
+		return nil, nil
+	}
+
+	espressoSubmitter, err := config.SubmitterCreator(
+		WithTransactionStreamer(streamer),
+		submitter.WithEspressoClient(config.EspressoClient),
+		submitter.WithLightClientReader(config.LightClientReader),
+		submitter.WithKeyManager(config.KeyManager),
+		submitter.WithTxnsMonitoringInterval(config.TxnsMonitoringInterval),
+		submitter.WithMaxTransactionSize(config.MaxTransactionSize),
+		submitter.WithInitialFinalizedSequencerMessageCount(config.InitialFinalizedSequencerMessageCount),
+		submitter.WithResubmitEspressoTxDeadline(config.ResubmitEspressoTxDeadline),
+		submitter.WithMultipleOptions(config.SubmitterConfiguration...),
+	)
+
+	streamer.espressoSubmitter = espressoSubmitter
+	return espressoSubmitter, err
+}
+
+// GetEspressoSubmitter is a helper function that retrieves the
+// EspressoSubmitter from the TransactionStreamer. This is useful for
+// accessing the EspressoSubmitter without needing to know the internal
+// details of the TransactionStreamer implementation.
+func GetEspressoSubmitter(
+	streamer *TransactionStreamer,
+) submitter.EspressoSubmitter {
+	return streamer.espressoSubmitter
+}
diff --git a/arbnode/espresso_utils.go b/arbnode/espresso_utils.go
new file mode 100644
index 00000000000..edc810a290e
--- /dev/null
+++ b/arbnode/espresso_utils.go
@@ -0,0 +1,65 @@
+package arbnode
+
+import (
+	"context"
+	"crypto/ecdsa"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+
+	"github.com/offchainlabs/nitro/espresso/key-manager"
+	"github.com/offchainlabs/nitro/util/signature"
+)
+
+var TestEspressoPrivateKey *ecdsa.PrivateKey = keymanager.TestEspressoPrivateKey
+
+var BlockSignaturePrefix = []byte("blockSignature")
+
+var (
+	binarySearch_LessThanTarget    = -1
+	binarySearch_GreaterThanTarget = 1
+	binarySearch_EqualToTarget     = 0
+)
+
+// Looks for the first block number that is equal to or greater than the target
+func binarySearchForBlockNumber(
+	ctx context.Context,
+	start, end uint64,
+	f func(context.Context, uint64) (int, error),
+) (uint64, error) {
+	for start < end {
+		mid := (start + end) / 2
+		result, err := f(ctx, mid)
+		if err != nil {
+			return 0, err
+		}
+		if result == binarySearch_GreaterThanTarget {
+			end = mid
+		} else if result == binarySearch_LessThanTarget {
+			start = mid + 1
+		} else {
+			// We are looking for the first block number.
+			// So the loop should continue until start == end
+			end = mid
+		}
+	}
+	return start, nil
+}
+
+// We should be able to get the address as soon as we have the signer.
+// We don't want to change a lot of code to make this work since we are working on a forked repo.
+// This function is not costly and it should be called only once.
+func recoverAddressFromSigner(signer signature.DataSignerFunc) (common.Address, error) {
+	message := make([]byte, 32)
+	signature, err := signer(message)
+	if err != nil {
+		return common.Address{}, err
+	}
+
+	publicKey, err := crypto.SigToPub(message, signature)
+	if err != nil {
+		return common.Address{}, err
+	}
+
+	return crypto.PubkeyToAddress(*publicKey), nil
+}
diff --git a/arbnode/espresso_utils_test.go b/arbnode/espresso_utils_test.go
new file mode 100644
index 00000000000..1adf2147d05
--- /dev/null
+++ b/arbnode/espresso_utils_test.go
@@ -0,0 +1,74 @@
+package arbnode
+
+import (
+	"context"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/crypto"
+
+	"github.com/offchainlabs/nitro/util/signature"
+)
+
+func TestRecoverAddressFromSigner(t *testing.T) {
+	privateKey, err := crypto.GenerateKey()
+	if err != nil {
+		t.Fatal(err)
+	}
+	address, err := recoverAddressFromSigner(signature.DataSignerFromPrivateKey(privateKey))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if address != crypto.PubkeyToAddress(privateKey.PublicKey) {
+		t.Fatalf("expected address %v, got %v", crypto.PubkeyToAddress(privateKey.PublicKey), address)
+	}
+}
+
+func TestBinarySearchForBlockNumber(t *testing.T) {
+	target := uint64(64)
+	count := 0
+	ctx := context.Background()
+	start := uint64(0)
+	end := uint64(100)
+	f := func(ctx context.Context, blockNumber uint64) (int, error) {
+		count++
+		if blockNumber < target {
+			return -1, nil
+		} else if blockNumber > target {
+			return 1, nil
+		}
+		return 0, nil
+	}
+	result, err := binarySearchForBlockNumber(ctx, start, end, f)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result != target {
+		t.Fatalf("expected result %d, got %d", target, result)
+	}
+	if count > 7 {
+		t.Fatalf("expected count less than %d, got %d", 7, count)
+	}
+
+	targetRangeStart := uint64(60)
+	targetRangeEnd := uint64(70)
+	count = 0
+	f = func(ctx context.Context, blockNumber uint64) (int, error) {
+		count++
+		if blockNumber < targetRangeStart {
+			return -1, nil
+		} else if blockNumber > targetRangeEnd {
+			return 1, nil
+		}
+		return 0, nil
+	}
+	result, err = binarySearchForBlockNumber(ctx, start, end, f)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result != targetRangeStart {
+		t.Fatalf("expected result %d, got %d", targetRangeStart, result)
+	}
+	if count > 7 {
+		t.Fatalf("expected count less than %d, got %d", 7, count)
+	}
+}
diff --git a/arbnode/inbox_test.go b/arbnode/inbox_test.go
index 8081b39439d..19ef5fe1145 100644
--- a/arbnode/inbox_test.go
+++ b/arbnode/inbox_test.go
@@ -92,19 +92,25 @@ func (w *execClientWrapper) SetConsensusSyncData(syncData *execution.ConsensusSy
 }
 
 func (w *execClientWrapper) DigestMessage(num arbutil.MessageIndex, msg *arbostypes.MessageWithMetadata, msgForPrefetch *arbostypes.MessageWithMetadata) containers.PromiseInterface[*execution.MessageResult] {
-	return containers.NewReadyPromise(w.ExecutionEngine.DigestMessage(num, msg, msgForPrefetch))
+	// TODO: golangci-lint can't implicitly work
+	// with unpacking in generics, so here is quick fix
+	res, err := w.ExecutionEngine.DigestMessage(num, msg, msgForPrefetch)
+	return containers.NewReadyPromise(res, err)
 }
 
 func (w *execClientWrapper) Reorg(count arbutil.MessageIndex, newMessages []arbostypes.MessageWithMetadataAndBlockInfo, oldMessages []*arbostypes.MessageWithMetadata) containers.PromiseInterface[[]*execution.MessageResult] {
-	return containers.NewReadyPromise(w.ExecutionEngine.Reorg(count, newMessages, oldMessages))
+	res, err := w.ExecutionEngine.Reorg(count, newMessages, oldMessages)
+	return containers.NewReadyPromise(res, err)
 }
 
 func (w *execClientWrapper) HeadMessageIndex() containers.PromiseInterface[arbutil.MessageIndex] {
-	return containers.NewReadyPromise(w.ExecutionEngine.HeadMessageIndex())
+	res, err := w.ExecutionEngine.HeadMessageIndex()
+	return containers.NewReadyPromise(res, err)
 }
 
 func (w *execClientWrapper) ResultAtMessageIndex(pos arbutil.MessageIndex) containers.PromiseInterface[*execution.MessageResult] {
-	return containers.NewReadyPromise(w.ExecutionEngine.ResultAtMessageIndex(pos))
+	res, err := w.ExecutionEngine.ResultAtMessageIndex(pos)
+	return containers.NewReadyPromise(res, err)
 }
 
 func (w *execClientWrapper) Start(ctx context.Context) error {
@@ -116,7 +122,8 @@ func (w *execClientWrapper) MessageIndexToBlockNumber(messageNum arbutil.Message
 }
 
 func (w *execClientWrapper) BlockNumberToMessageIndex(blockNum uint64) containers.PromiseInterface[arbutil.MessageIndex] {
-	return containers.NewReadyPromise(w.ExecutionEngine.BlockNumberToMessageIndex(blockNum))
+	res, err := w.ExecutionEngine.BlockNumberToMessageIndex(blockNum)
+	return containers.NewReadyPromise(res, err)
 }
 
 func (w *execClientWrapper) ArbOSVersionForMessageIndex(msgIdx arbutil.MessageIndex) containers.PromiseInterface[uint64] {
diff --git a/arbnode/mel/extraction/batch_serialization.go b/arbnode/mel/extraction/batch_serialization.go
index eea875e7422..66a7dc5095d 100644
--- a/arbnode/mel/extraction/batch_serialization.go
+++ b/arbnode/mel/extraction/batch_serialization.go
@@ -65,7 +65,7 @@ func getSequencerBatchData(
 	txIndex uint,
 	receiptFetcher ReceiptFetcher,
 ) ([]byte, error) {
-	addSequencerL2BatchFromOriginCallABI := seqInboxABI.Methods["addSequencerL2BatchFromOrigin0"]
+	addSequencerL2BatchFromOriginCallABI := seqInboxABI.Methods["addSequencerL2BatchFromOrigin1"]
 	switch batch.DataLocation {
 	case mel.BatchDataTxInput:
 		data := tx.Data()
diff --git a/arbnode/mel/extraction/batch_serialization_test.go b/arbnode/mel/extraction/batch_serialization_test.go
index de217a0590d..27e47142f45 100644
--- a/arbnode/mel/extraction/batch_serialization_test.go
+++ b/arbnode/mel/extraction/batch_serialization_test.go
@@ -140,7 +140,7 @@ func Test_getSequencerBatchData(t *testing.T) {
 	})
 	t.Run("arbnode.BatchDataTxInput", func(t *testing.T) {
 		msgData := []byte("foobar")
-		addSequencerL2BatchFromOriginCallABI := seqInboxABI.Methods["addSequencerL2BatchFromOrigin0"]
+		addSequencerL2BatchFromOriginCallABI := seqInboxABI.Methods["addSequencerL2BatchFromOrigin1"]
 		seqNumber := big.NewInt(1)
 		afterDelayedRead := big.NewInt(1)
 		gasRefunder := common.Address{}
diff --git a/arbnode/node.go b/arbnode/node.go
index 476d821edd7..e44f6ed97aa 100644
--- a/arbnode/node.go
+++ b/arbnode/node.go
@@ -38,6 +38,7 @@ import (
 	"github.com/offchainlabs/nitro/daprovider/das"
 	"github.com/offchainlabs/nitro/daprovider/data_streaming"
 	"github.com/offchainlabs/nitro/daprovider/factory"
+	"github.com/offchainlabs/nitro/espressostreamer"
 	"github.com/offchainlabs/nitro/execution"
 	"github.com/offchainlabs/nitro/execution/gethexec"
 	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
@@ -56,6 +57,12 @@ import (
 	"github.com/offchainlabs/nitro/wsbroadcastserver"
 )
 
+type EspressoConfig struct {
+	CaffNode    EspressoCaffNodeConfig                  `koanf:"caff-node"`
+	BatchPoster EspressoBatchPosterConfig               `koanf:"batch-poster"`
+	Streamer    espressostreamer.EspressoStreamerConfig `koanf:"streamer"`
+}
+
 type Config struct {
 	Sequencer                bool                           `koanf:"sequencer"`
 	ParentChainReader        headerreader.Config            `koanf:"parent-chain-reader" reload:"hot"`
@@ -79,6 +86,8 @@ type Config struct {
 	ConsensusExecutionSyncer ConsensusExecutionSyncerConfig `koanf:"consensus-execution-syncer"`
 	// SnapSyncConfig is only used for testing purposes, these should not be configured in production.
 	SnapSyncTest SnapSyncConfig
+
+	Espresso EspressoConfig `koanf:"espresso" reload:"hot"`
 }
 
 func (c *Config) Validate() error {
@@ -95,6 +104,9 @@ func (c *Config) Validate() error {
 		c.Feed.Output.Enable = false
 		c.Feed.Input.URL = []string{}
 	}
+	if c.Espresso.CaffNode.Enable && (c.Sequencer || c.DelayedSequencer.Enable || c.SeqCoordinator.Enable) {
+		return errors.New("cannot start a Caff node with any sequencer enabled")
+	}
 	if err := c.BlockValidator.Validate(); err != nil {
 		return err
 	}
@@ -156,6 +168,15 @@ func ConfigAddOptions(prefix string, f *pflag.FlagSet, feedInputEnable bool, fee
 	resourcemanager.ConfigAddOptions(prefix+".resource-mgmt", f)
 	BlockMetadataFetcherConfigAddOptions(prefix+".block-metadata-fetcher", f)
 	ConsensusExecutionSyncerConfigAddOptions(prefix+".consensus-execution-syncer", f)
+	EspressoCaffNodeConfigAddOptions(prefix+".espresso.caff-node", f)
+	EspressoBatchPosterConfigAddOptions(prefix+".espresso.batch-poster", f)
+	espressostreamer.EspressoStreamerConfigAddOptions(prefix+".espresso.streamer", f)
+}
+
+var EspressoConfigDefault = EspressoConfig{
+	CaffNode:    DefaultEspressoCaffNodeConfig,
+	BatchPoster: DefaultEspressoBatchPosterConfig,
+	Streamer:    espressostreamer.DefaultEspressoStreamerConfig,
 }
 
 var ConfigDefault = Config{
@@ -180,6 +201,8 @@ var ConfigDefault = Config{
 	Maintenance:              DefaultMaintenanceConfig,
 	ConsensusExecutionSyncer: DefaultConsensusExecutionSyncerConfig,
 	SnapSyncTest:             DefaultSnapSyncConfig,
+
+	Espresso: EspressoConfigDefault,
 }
 
 func ConfigDefaultL1Test() *Config {
@@ -286,6 +309,8 @@ type Node struct {
 	configFetcher            ConfigFetcher
 	ctx                      context.Context
 	ConsensusExecutionSyncer *ConsensusExecutionSyncer
+
+	EspressoCaffNode *EspressoCaffNode
 }
 
 type SnapSyncConfig struct {
@@ -955,6 +980,9 @@ func getBatchPoster(
 	parentChainID *big.Int,
 	dapReaders *daprovider.ReaderRegistry,
 	stakerAddr common.Address,
+	dataSigner signature.DataSignerFunc,
+	l2ChainId uint64,
+	fatalErrChan chan error,
 ) (*BatchPoster, error) {
 	var batchPoster *BatchPoster
 	if config.BatchPoster.Enable {
@@ -970,6 +998,7 @@ func getBatchPoster(
 		}
 		var err error
 		batchPoster, err = NewBatchPoster(ctx, &BatchPosterOpts{
+			ChainID:       l2ChainId,
 			DataPosterDB:  rawdb.NewTable(arbDb, storage.BatchPosterPrefix),
 			L1Reader:      l1Reader,
 			Inbox:         inboxTracker,
@@ -982,6 +1011,13 @@ func getBatchPoster(
 			DAPWriter:     dapWriter,
 			ParentChainID: parentChainID,
 			DAPReaders:    dapReaders,
+
+			DataSigner: dataSigner,
+
+			EspressoConfigFetcher: func() *EspressoConfig {
+				return &configFetcher.Get().Espresso
+			},
+			FatalErrChan: fatalErrChan,
 		})
 		if err != nil {
 			return nil, err
@@ -996,6 +1032,83 @@ func getBatchPoster(
 	return batchPoster, nil
 }
 
+func getEspressoCaffNode(
+	ctx context.Context,
+	config *Config,
+	configFetcher ConfigFetcher,
+	arbDb ethdb.Database,
+	chainDb ethdb.Database,
+	exec execution.ExecutionClient,
+	l1Reader *headerreader.HeaderReader,
+	txStreamer *TransactionStreamer,
+	blobReader daprovider.BlobReader,
+	broadcastServer *broadcaster.Broadcaster,
+	broadcastClients *broadcastclients.BroadcastClients,
+	delayedBridge *DelayedBridge,
+	maintenanceRunner *MaintenanceRunner,
+	stack *node.Node,
+	sequencerInbox *SequencerInbox,
+	fatalErrChan chan error,
+	caffNodeInitArgs *EspressoCaffNodeInitArgs,
+) (*Node, error) {
+	if config.Espresso.CaffNode.Enable {
+
+		if exec, ok := exec.(*gethexec.ExecutionNode); ok {
+			espressoCaffNode, err := NewEspressoCaffNode(
+				ctx,
+				func() *EspressoCaffNodeConfig { return &config.Espresso.CaffNode },
+				chainDb,
+				exec.ExecEngine,
+				delayedBridge,
+				l1Reader,
+				config.Espresso.CaffNode.RecordPerformance,
+				sequencerInbox,
+				fatalErrChan,
+				stack,
+				rawdb.NewTable(arbDb, storage.CaffNodePrefix),
+				caffNodeInitArgs,
+				func() *espressostreamer.EspressoStreamerConfig {
+					return &configFetcher.Get().Espresso.Streamer
+				},
+			)
+			if err != nil {
+				return nil, fmt.Errorf("failed to create espressoCaffNode: %w", err)
+			}
+
+			return &Node{
+				ArbDB:                   nil,
+				Stack:                   stack,
+				ExecutionClient:         exec,
+				L1Reader:                nil,
+				TxStreamer:              txStreamer,
+				DeployInfo:              nil,
+				BlobReader:              blobReader,
+				InboxReader:             nil,
+				InboxTracker:            nil,
+				DelayedSequencer:        nil,
+				BatchPoster:             nil,
+				MessagePruner:           nil,
+				BlockValidator:          nil,
+				StatelessBlockValidator: nil,
+				Staker:                  nil,
+				BroadcastServer:         broadcastServer,
+				BroadcastClients:        broadcastClients,
+				SeqCoordinator:          nil,
+				MaintenanceRunner:       maintenanceRunner,
+				DASLifecycleManager:     nil,
+				SyncMonitor:             nil,
+				configFetcher:           configFetcher,
+				EspressoCaffNode:        espressoCaffNode,
+				ctx:                     ctx,
+			}, nil
+
+		} else {
+			return nil, errors.New("execution engine is not a gethexec.ExecutionNode while espresso caff node is enabled")
+		}
+	}
+	return nil, nil
+}
+
 func getDelayedSequencer(
 	l1Reader *headerreader.HeaderReader,
 	inboxReader *InboxReader,
@@ -1083,6 +1196,7 @@ func createNodeImpl(
 	executionRecorder execution.ExecutionRecorder,
 	arbOSVersionGetter execution.ArbOSVersionGetter,
 	arbDb ethdb.Database,
+	chainDb ethdb.Database,
 	configFetcher ConfigFetcher,
 	l2Config *params.ChainConfig,
 	l1client *ethclient.Client,
@@ -1094,6 +1208,7 @@ func createNodeImpl(
 	parentChainID *big.Int,
 	blobReader daprovider.BlobReader,
 	latestWasmModuleRoot common.Hash,
+	caffNodeInitArgs *EspressoCaffNodeInitArgs,
 ) (*Node, error) {
 	config := configFetcher.Get()
 
@@ -1158,6 +1273,15 @@ func createNodeImpl(
 		return nil, err
 	}
 
+	caffNode, err := getEspressoCaffNode(ctx, config, configFetcher, arbDb, chainDb, executionClient, l1Reader, txStreamer, blobReader, broadcastServer, broadcastClients, delayedBridge, maintenanceRunner, stack, sequencerInbox, fatalErrChan, caffNodeInitArgs)
+	if err != nil {
+		return nil, err
+	}
+
+	if caffNode != nil {
+		return caffNode, nil
+	}
+
 	inboxTracker, inboxReader, err := getInboxTrackerAndReader(ctx, arbDb, txStreamer, dapReaders, config, configFetcher, l1client, l1Reader, deployInfo, delayedBridge, sequencerInbox, executionSequencer)
 	if err != nil {
 		return nil, err
@@ -1178,7 +1302,7 @@ func createNodeImpl(
 		return nil, err
 	}
 
-	batchPoster, err := getBatchPoster(ctx, config, configFetcher, txOptsBatchPoster, dapWriter, l1Reader, inboxTracker, txStreamer, arbOSVersionGetter, arbDb, syncMonitor, deployInfo, parentChainID, dapReaders, stakerAddr)
+	batchPoster, err := getBatchPoster(ctx, config, configFetcher, txOptsBatchPoster, dapWriter, l1Reader, inboxTracker, txStreamer, arbOSVersionGetter, arbDb, syncMonitor, deployInfo, parentChainID, dapReaders, stakerAddr, dataSigner, l2Config.ChainID.Uint64(), fatalErrChan)
 	if err != nil {
 		return nil, err
 	}
@@ -1304,6 +1428,7 @@ func CreateNodeExecutionClient(
 	stack *node.Node,
 	executionClient execution.ExecutionClient,
 	arbDb ethdb.Database,
+	chainDb ethdb.Database,
 	configFetcher ConfigFetcher,
 	l2Config *params.ChainConfig,
 	l1client *ethclient.Client,
@@ -1315,11 +1440,12 @@ func CreateNodeExecutionClient(
 	parentChainID *big.Int,
 	blobReader daprovider.BlobReader,
 	latestWasmModuleRoot common.Hash,
+	caffNodeInitArgs *EspressoCaffNodeInitArgs,
 ) (*Node, error) {
 	if executionClient == nil {
 		return nil, errors.New("execution client must be non-nil")
 	}
-	currentNode, err := createNodeImpl(ctx, stack, executionClient, nil, nil, nil, arbDb, configFetcher, l2Config, l1client, deployInfo, txOptsValidator, txOptsBatchPoster, dataSigner, fatalErrChan, parentChainID, blobReader, latestWasmModuleRoot)
+	currentNode, err := createNodeImpl(ctx, stack, executionClient, nil, nil, nil, arbDb, chainDb, configFetcher, l2Config, l1client, deployInfo, txOptsValidator, txOptsBatchPoster, dataSigner, fatalErrChan, parentChainID, blobReader, latestWasmModuleRoot, caffNodeInitArgs)
 	if err != nil {
 		return nil, err
 	}
@@ -1335,6 +1461,7 @@ func CreateNodeFullExecutionClient(
 	executionRecorder execution.ExecutionRecorder,
 	arbOSVersionGetter execution.ArbOSVersionGetter,
 	arbDb ethdb.Database,
+	chainDb ethdb.Database,
 	configFetcher ConfigFetcher,
 	l2Config *params.ChainConfig,
 	l1client *ethclient.Client,
@@ -1346,11 +1473,12 @@ func CreateNodeFullExecutionClient(
 	parentChainID *big.Int,
 	blobReader daprovider.BlobReader,
 	latestWasmModuleRoot common.Hash,
+	caffNodeInitArgs *EspressoCaffNodeInitArgs,
 ) (*Node, error) {
 	if (executionClient == nil) || (executionSequencer == nil) || (executionRecorder == nil) || (arbOSVersionGetter == nil) {
 		return nil, errors.New("execution client, sequencer, recorder, and ArbOS version getter must be non-nil")
 	}
-	currentNode, err := createNodeImpl(ctx, stack, executionClient, executionSequencer, executionRecorder, arbOSVersionGetter, arbDb, configFetcher, l2Config, l1client, deployInfo, txOptsValidator, txOptsBatchPoster, dataSigner, fatalErrChan, parentChainID, blobReader, latestWasmModuleRoot)
+	currentNode, err := createNodeImpl(ctx, stack, executionClient, executionSequencer, executionRecorder, arbOSVersionGetter, arbDb, chainDb, configFetcher, l2Config, l1client, deployInfo, txOptsValidator, txOptsBatchPoster, dataSigner, fatalErrChan, parentChainID, blobReader, latestWasmModuleRoot, caffNodeInitArgs)
 	if err != nil {
 		return nil, err
 	}
@@ -1493,6 +1621,13 @@ func (n *Node) Start(ctx context.Context) error {
 	if n.configFetcher != nil {
 		n.configFetcher.Start(ctx)
 	}
+	if n.EspressoCaffNode != nil {
+		err = n.EspressoCaffNode.Start(ctx)
+		if err != nil {
+			return fmt.Errorf("error starting espresso caff node: %w", err)
+		}
+		return nil
+	}
 	// Also make sure to call initialize on the sync monitor after the inbox reader, tx streamer, and block validator are started.
 	// Else sync might call inbox reader or tx streamer before they are started, and it will lead to panic.
 	n.SyncMonitor.Initialize(n.InboxReader, n.TxStreamer, n.SeqCoordinator)
@@ -1537,6 +1672,7 @@ func (n *Node) StopAndWait() {
 	if n.BlockValidator != nil && n.BlockValidator.Started() {
 		n.BlockValidator.StopAndWait()
 	}
+
 	if n.Staker != nil {
 		n.Staker.StopAndWait()
 	}
@@ -1561,16 +1697,23 @@ func (n *Node) StopAndWait() {
 		// Just stops the redis client (most other stuff was stopped earlier)
 		n.SeqCoordinator.StopAndWait()
 	}
-	n.SyncMonitor.StopAndWait()
+
+	if n.SyncMonitor != nil {
+		n.SyncMonitor.StopAndWait()
+	}
 	if n.dasServerCloseFn != nil {
 		n.dasServerCloseFn()
 	}
 	if n.ExecutionClient != nil {
 		n.ExecutionClient.StopAndWait()
 	}
+	if n.EspressoCaffNode != nil {
+		n.EspressoCaffNode.StopAndWait()
+	}
 	if err := n.Stack.Close(); err != nil {
 		log.Error("error on stack close", "err", err)
 	}
+
 }
 
 func (n *Node) FindInboxBatchContainingMessage(message arbutil.MessageIndex) containers.PromiseInterface[execution.InboxBatch] {
diff --git a/arbnode/sequencer_inbox.go b/arbnode/sequencer_inbox.go
index 30a3bda3813..0c581838732 100644
--- a/arbnode/sequencer_inbox.go
+++ b/arbnode/sequencer_inbox.go
@@ -46,7 +46,7 @@ func init() {
 	}
 	batchDeliveredID = sequencerBridgeABI.Events["SequencerBatchDelivered"].ID
 	sequencerBatchDataABI = sequencerBridgeABI.Events[sequencerBatchDataEvent]
-	addSequencerL2BatchFromOriginCallABI = sequencerBridgeABI.Methods["addSequencerL2BatchFromOrigin0"]
+	addSequencerL2BatchFromOriginCallABI = sequencerBridgeABI.Methods["addSequencerL2BatchFromOrigin1"]
 }
 
 type SequencerInbox struct {
diff --git a/arbnode/transaction_streamer.go b/arbnode/transaction_streamer.go
index de81babaf63..a4ccebe2ca0 100644
--- a/arbnode/transaction_streamer.go
+++ b/arbnode/transaction_streamer.go
@@ -33,6 +33,7 @@ import (
 	"github.com/offchainlabs/nitro/broadcastclient"
 	"github.com/offchainlabs/nitro/broadcaster"
 	"github.com/offchainlabs/nitro/broadcaster/message"
+	"github.com/offchainlabs/nitro/espresso/submitter"
 	"github.com/offchainlabs/nitro/execution"
 	"github.com/offchainlabs/nitro/staker"
 	"github.com/offchainlabs/nitro/util/arbmath"
@@ -76,6 +77,7 @@ type TransactionStreamer struct {
 
 	trackBlockMetadataFrom arbutil.MessageIndex
 	syncTillMessage        arbutil.MessageIndex
+	espressoSubmitter      submitter.EspressoSubmitter
 }
 
 type TransactionStreamerConfig struct {
@@ -85,6 +87,9 @@ type TransactionStreamerConfig struct {
 	SyncTillBlock               uint64        `koanf:"sync-till-block"`
 	TrackBlockMetadataFrom      uint64        `koanf:"track-block-metadata-from"`
 	ShutdownOnBlockhashMismatch bool          `koanf:"shutdown-on-blockhash-mismatch"`
+
+	UserDataAttestationFile string `koanf:"user-data-attestation-file"`
+	QuoteFile               string `koanf:"quote-file"`
 }
 
 type TransactionStreamerConfigFetcher func() *TransactionStreamerConfig
@@ -96,6 +101,9 @@ var DefaultTransactionStreamerConfig = TransactionStreamerConfig{
 	SyncTillBlock:               0,
 	TrackBlockMetadataFrom:      0,
 	ShutdownOnBlockhashMismatch: false,
+
+	QuoteFile:               "",
+	UserDataAttestationFile: "",
 }
 
 var TestTransactionStreamerConfig = TransactionStreamerConfig{
@@ -114,6 +122,8 @@ func TransactionStreamerConfigAddOptions(prefix string, f *pflag.FlagSet) {
 	f.Uint64(prefix+".sync-till-block", DefaultTransactionStreamerConfig.SyncTillBlock, "node will not sync past this block")
 	f.Uint64(prefix+".track-block-metadata-from", DefaultTransactionStreamerConfig.TrackBlockMetadataFrom, "block number to start saving blockmetadata, 0 to disable")
 	f.Bool(prefix+".shutdown-on-blockhash-mismatch", DefaultTransactionStreamerConfig.ShutdownOnBlockhashMismatch, "if set the node gracefully shuts down upon detecting mismatch in feed and locally computed blockhash. This is turned off by default")
+	f.String(prefix+".user-data-attestation-file", DefaultTransactionStreamerConfig.UserDataAttestationFile, "specifies the file containing the user data attestation")
+	f.String(prefix+".quote-file", DefaultTransactionStreamerConfig.QuoteFile, "specifies the file containing the quote")
 }
 
 func NewTransactionStreamer(
@@ -1220,6 +1230,11 @@ func (s *TransactionStreamer) writeMessages(firstMsgIdx arbutil.MessageIndex, me
 		batch = s.db.NewBatch()
 	}
 	for i, msg := range messages {
+		if len(msg.MessageWithMeta.Message.L2msg) > arbostypes.MaxL2MessageSize {
+			// #nosec G115
+			log.Warn("L2 message is too large", "pos", firstMsgIdx+arbutil.MessageIndex(i), "size", len(msg.MessageWithMeta.Message.L2msg))
+			return fmt.Errorf("L2 message is too large")
+		}
 		// #nosec G115
 		err := s.writeMessage(firstMsgIdx+arbutil.MessageIndex(i), msg, batch)
 		if err != nil {
@@ -1231,6 +1246,16 @@ func (s *TransactionStreamer) writeMessages(firstMsgIdx arbutil.MessageIndex, me
 	if err != nil {
 		return err
 	}
+
+	//  If light client reader and espresso client are set, then we need to store the pos in the database
+	//  to be used later to submit the message to hotshot for finalization.
+	if submitter := s.espressoSubmitter; submitter != nil {
+		err = s.espressoSubmitter.NotifyNewPendingMessages(firstMsgIdx, messages)
+		if err != nil {
+			return err
+		}
+	}
+
 	err = batch.Write()
 	if err != nil {
 		return err
@@ -1505,5 +1530,14 @@ func (s *TransactionStreamer) backfillTrackersForMissingBlockMetadata(ctx contex
 func (s *TransactionStreamer) Start(ctxIn context.Context) error {
 	s.StopWaiter.Start(ctxIn, s)
 	s.LaunchThread(s.backfillTrackersForMissingBlockMetadata)
+
+	if submitter := s.espressoSubmitter; submitter != nil {
+		if err := submitter.Start(&s.StopWaiter); err != nil {
+			return err
+		}
+	} else {
+		log.Warn("light client reader or espresso client not set, skipping espresso verification")
+	}
+
 	return stopwaiter.CallIterativelyWith[struct{}](&s.StopWaiterSafe, s.executeMessages, s.newMessageNotifier)
 }
diff --git a/arbutil/espresso_util_test.go b/arbutil/espresso_util_test.go
new file mode 100644
index 00000000000..e9e25949dad
--- /dev/null
+++ b/arbutil/espresso_util_test.go
@@ -0,0 +1,223 @@
+package arbutil
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"os"
+	"slices"
+	"testing"
+
+	espressoTypes "github.com/EspressoSystems/espresso-network/sdks/go/types"
+
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+func mockMsgFetcher(index MessageIndex) ([]byte, error) {
+	return []byte("message" + fmt.Sprint(index)), nil
+}
+
+func TestParsePayload(t *testing.T) {
+	msgPositions := []MessageIndex{1, 2, 10, 24, 100}
+
+	rawPayload, cnt := BuildRawHotShotPayload(msgPositions, mockMsgFetcher, 200*1024)
+	if cnt != len(msgPositions) {
+		t.Fatal("exceed transactions")
+	}
+
+	mockSignature := []byte("fake_signature")
+	fakeSigner := func(payload []byte) ([]byte, error) {
+		return mockSignature, nil
+	}
+	signedPayload, err := SignHotShotPayload(rawPayload, fakeSigner)
+	if err != nil {
+		t.Fatalf("failed to sign payload: %v", err)
+	}
+
+	// Parse the signed payload
+	signature, userDataHash, indices, messages, err := ParseHotShotPayload(signedPayload)
+	if err != nil {
+		t.Fatalf("failed to parse payload: %v", err)
+	}
+
+	if !slices.Equal(userDataHash, crypto.Keccak256(rawPayload)) {
+		t.Fatalf("User data hash is not for the correct payload")
+	}
+
+	// Validate parsed data
+	if !bytes.Equal(signature, mockSignature) {
+		t.Errorf("expected signature 'fake_signature', got %v", mockSignature)
+	}
+
+	for i, index := range indices {
+		if MessageIndex(index) != msgPositions[i] {
+			t.Errorf("expected index %d, got %d", msgPositions[i], index)
+		}
+	}
+
+	expectedMessages := [][]byte{
+		[]byte("message1"),
+		[]byte("message2"),
+		[]byte("message10"),
+		[]byte("message24"),
+		[]byte("message100"),
+	}
+	for i, message := range messages {
+		if !bytes.Equal(message, expectedMessages[i]) {
+			t.Errorf("expected message %s, got %s", expectedMessages[i], message)
+		}
+	}
+}
+
+func TestValidateIfPayloadIsInBlock(t *testing.T) {
+	msgPositions := []MessageIndex{1, 2}
+
+	rawPayload, _ := BuildRawHotShotPayload(msgPositions, mockMsgFetcher, 200*1024)
+	fakeSigner := func(payload []byte) ([]byte, error) {
+		return []byte("fake_signature"), nil
+	}
+	signedPayload, err := SignHotShotPayload(rawPayload, fakeSigner)
+	if err != nil {
+		t.Fatalf("failed to sign payload: %v", err)
+	}
+
+	// Validate payload in a block
+	blockPayloads := []espressoTypes.Bytes{
+		signedPayload,
+		[]byte("other_payload"),
+	}
+
+	if !ValidateIfPayloadIsInBlock(signedPayload, blockPayloads) {
+		t.Error("expected payload to be validated in block")
+	}
+
+	if ValidateIfPayloadIsInBlock([]byte("invalid_payload"), blockPayloads) {
+		t.Error("did not expect invalid payload to be validated in block")
+	}
+}
+
+func TestParsePayloadInvalidCases(t *testing.T) {
+	invalidPayloads := []struct {
+		description string
+		payload     []byte
+	}{
+		{
+			description: "Empty payload",
+			payload:     []byte{},
+		},
+		{
+			description: "Message size exceeds remaining payload",
+			payload: func() []byte {
+				var payload []byte
+				sigSizeBuf := make([]byte, 8)
+				binary.BigEndian.PutUint64(sigSizeBuf, 0)
+				payload = append(payload, sigSizeBuf...)
+				msgSizeBuf := make([]byte, 8)
+				binary.BigEndian.PutUint64(msgSizeBuf, 100)
+				payload = append(payload, msgSizeBuf...)
+				return payload
+			}(),
+		},
+	}
+
+	for _, tc := range invalidPayloads {
+		t.Run(tc.description, func(t *testing.T) {
+			_, _, _, _, err := ParseHotShotPayload(tc.payload)
+			if err == nil {
+				t.Errorf("expected error for case '%s', but got none", tc.description)
+			}
+		})
+	}
+}
+
+func TestSerdeSubmittedEspressoTx(t *testing.T) {
+	submiitedTx := SubmittedEspressoTx{
+		Hash:    "0x1234",
+		Pos:     []MessageIndex{MessageIndex(10)},
+		Payload: []byte{0, 1, 2, 3},
+	}
+
+	b, err := rlp.EncodeToBytes(&submiitedTx)
+	if err != nil {
+		t.Error("failed to encode")
+	}
+
+	var expected SubmittedEspressoTx
+	err = rlp.DecodeBytes(b, &expected)
+	if err != nil {
+		t.Error("failed to encode")
+	}
+
+	if submiitedTx.Hash != expected.Hash {
+		t.Error("failed to check hash")
+	}
+
+	if submiitedTx.Pos[0] != expected.Pos[0] {
+		t.Error("failed to check pos")
+	}
+
+	if !bytes.Equal(submiitedTx.Payload, expected.Payload) {
+		t.Error("failed to check payload")
+	}
+}
+
+func TestSerdeSubmittedEspressoTxBackwardCompatibility(t *testing.T) {
+	// This test ensures that we can deserialize the old SubmittedEspressoTx, which did not have
+	// the `SubmittedAt` field, into the new struct. It uses a static RLP-encoded artifact
+	// generated from the old struct definition. See testdata/old_submitted_espresso_tx.md for details.
+	type OldSubmittedEspressoTx struct {
+		Hash    string
+		Pos     []MessageIndex
+		Payload []byte
+	}
+
+	// This represents the original data that was used to create the RLP artifact.
+	oldSubmittedTx := OldSubmittedEspressoTx{
+		Hash:    "0x1234",
+		Pos:     []MessageIndex{MessageIndex(10)},
+		Payload: []byte{0, 1, 2, 3},
+	}
+
+	b, err := os.ReadFile("testdata/old_submitted_espresso_tx.rlp")
+	if err != nil {
+		t.Fatalf("Failed to read RLP artifact: %v", err)
+	}
+
+	// First, validate that the artifact correctly decodes to the old struct format.
+	var decodedOldTx OldSubmittedEspressoTx
+	if err := rlp.DecodeBytes(b, &decodedOldTx); err != nil {
+		t.Fatalf("Failed to decode artifact into OldSubmittedEspressoTx: %v", err)
+	}
+	if decodedOldTx.Hash != oldSubmittedTx.Hash {
+		t.Errorf("Hash mismatch in old struct: got %v, want %v", decodedOldTx.Hash, oldSubmittedTx.Hash)
+	}
+	if len(decodedOldTx.Pos) != 1 || decodedOldTx.Pos[0] != oldSubmittedTx.Pos[0] {
+		t.Errorf("Pos mismatch in old struct: got %v, want %v", decodedOldTx.Pos, oldSubmittedTx.Pos)
+	}
+	if !bytes.Equal(decodedOldTx.Payload, oldSubmittedTx.Payload) {
+		t.Errorf("Payload mismatch in old struct: got %x, want %x", decodedOldTx.Payload, oldSubmittedTx.Payload)
+	}
+
+	// Now, decode the same artifact into the new struct to test backward compatibility.
+	var expected SubmittedEspressoTx
+	if err := rlp.DecodeBytes(b, &expected); err != nil {
+		t.Fatalf("Failed to decode artifact into new SubmittedEspressoTx: %v", err)
+	}
+
+	if oldSubmittedTx.Hash != expected.Hash {
+		t.Errorf("Failed to check hash after decoding, got %v, want %v", expected.Hash, oldSubmittedTx.Hash)
+	}
+
+	if len(expected.Pos) != 1 || oldSubmittedTx.Pos[0] != expected.Pos[0] {
+		t.Errorf("Pos mismatch: got %v, want %v", expected.Pos, oldSubmittedTx.Pos)
+	}
+
+	if !bytes.Equal(oldSubmittedTx.Payload, expected.Payload) {
+		t.Errorf("Payload mismatch: got %x, want %x", expected.Payload, oldSubmittedTx.Payload)
+	}
+
+	if !expected.SubmittedAt.IsZero() {
+		t.Errorf("Expected SubmittedAt to be zero after decoding old data, but got %v", expected.SubmittedAt)
+	}
+}
diff --git a/arbutil/espresso_utils.go b/arbutil/espresso_utils.go
new file mode 100644
index 00000000000..1360b738a5f
--- /dev/null
+++ b/arbutil/espresso_utils.go
@@ -0,0 +1,403 @@
+package arbutil
+
+import (
+	"bytes"
+	"crypto/ecdsa"
+	"encoding/base64"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	espressoTypes "github.com/EspressoSystems/espresso-network/sdks/go/types"
+	"github.com/ccoveille/go-safecast"
+	"github.com/minio/sha256-simd"
+	"golang.org/x/mod/sumdb/dirhash"
+
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+const MAX_ATTESTATION_QUOTE_SIZE int = 4 * 1024
+const LEN_SIZE int = 8
+const INDEX_SIZE int = 8
+
+type SubmittedEspressoTx struct {
+	Hash        string
+	Pos         []MessageIndex
+	Payload     []byte
+	SubmittedAt time.Time `rlp:"optional"`
+}
+
+func BuildRawHotShotPayload(
+	msgPositions []MessageIndex,
+	msgFetcher func(MessageIndex) ([]byte, error),
+	maxSize int64,
+) ([]byte, int) {
+
+	payload := []byte{}
+	msgCnt := 0
+
+	for _, p := range msgPositions {
+		msgBytes, err := msgFetcher(p)
+		if err != nil {
+			log.Warn("failed to fetch the message", "pos", p)
+			break
+		}
+
+		sizeBuf := make([]byte, LEN_SIZE)
+		positionBuf := make([]byte, INDEX_SIZE)
+
+		if len(payload)+len(sizeBuf)+len(msgBytes)+len(positionBuf)+MAX_ATTESTATION_QUOTE_SIZE > int(maxSize) {
+			break
+		}
+		binary.BigEndian.PutUint64(sizeBuf, uint64(len(msgBytes)))
+		binary.BigEndian.PutUint64(positionBuf, uint64(p))
+
+		// Add the submitted txn position and the size of the message along with the message
+		payload = append(payload, positionBuf...)
+		payload = append(payload, sizeBuf...)
+		payload = append(payload, msgBytes...)
+		msgCnt += 1
+	}
+	return payload, msgCnt
+}
+
+func SignHotShotPayload(
+	unsigned []byte,
+	signer func([]byte) ([]byte, error),
+) ([]byte, error) {
+	quote, err := signer(unsigned)
+	if err != nil {
+		return nil, err
+	}
+
+	quoteSizeBuf := make([]byte, LEN_SIZE)
+	binary.BigEndian.PutUint64(quoteSizeBuf, uint64(len(quote)))
+	// Put the signature first. That would help easier parsing.
+	result := quoteSizeBuf
+	result = append(result, quote...)
+	result = append(result, unsigned...)
+
+	return result, nil
+}
+
+func ValidateIfPayloadIsInBlock(p []byte, payloads []espressoTypes.Bytes) bool {
+	validated := false
+	for _, payload := range payloads {
+		if bytes.Equal(p, payload) {
+			validated = true
+			break
+		}
+	}
+	return validated
+}
+
+func ParseHotShotPayload(payload []byte) (signature []byte, userDataHash []byte, indices []uint64, messages [][]byte, err error) {
+	if len(payload) < LEN_SIZE {
+		return nil, nil, nil, nil, errors.New("payload too short to parse signature size")
+	}
+
+	// Extract the signature size
+	signatureSize, err := safecast.ToInt(binary.BigEndian.Uint64(payload[:LEN_SIZE]))
+	if err != nil {
+		return nil, nil, nil, nil, errors.New("could not convert signature size to int")
+	}
+
+	currentPos := LEN_SIZE
+
+	if len(payload[currentPos:]) < signatureSize {
+		return nil, nil, nil, nil, errors.New("payload too short for signature")
+	}
+
+	// Extract the signature
+	signature = payload[currentPos : currentPos+signatureSize]
+	currentPos += signatureSize
+
+	indices = []uint64{}
+	messages = [][]byte{}
+
+	// Take keccak256 hash of the rest of payload
+	userDataHash = crypto.Keccak256(payload[currentPos:])
+	// Parse messages
+	for {
+		if currentPos == len(payload) {
+			break
+		}
+		if len(payload[currentPos:]) < LEN_SIZE+INDEX_SIZE {
+			return nil, nil, nil, nil, errors.New("remaining bytes")
+		}
+
+		// Extract the index
+		index := binary.BigEndian.Uint64(payload[currentPos : currentPos+INDEX_SIZE])
+		currentPos += INDEX_SIZE
+
+		// Extract the message size
+		messageSize, err := safecast.ToInt(binary.BigEndian.Uint64(payload[currentPos : currentPos+LEN_SIZE]))
+		if err != nil {
+			return nil, nil, nil, nil, errors.New("could not convert message size to int")
+		}
+		currentPos += LEN_SIZE
+
+		if len(payload[currentPos:]) < messageSize {
+			return nil, nil, nil, nil, errors.New("message size mismatch")
+		}
+
+		// Extract the message
+		message := payload[currentPos : currentPos+messageSize]
+		currentPos += messageSize
+		if len(message) == 0 {
+			// If the message has a size of 0, skip adding it to the list.
+			continue
+		}
+
+		indices = append(indices, index)
+		messages = append(messages, message)
+	}
+
+	return signature, userDataHash, indices, messages, nil
+}
+
+var ignoreRE = []*regexp.Regexp{
+	regexp.MustCompile(`(^|/)LOCK$`),
+	regexp.MustCompile(`(^|/)FLOCK$`),
+	regexp.MustCompile(`(^|/)CURRENT(\.bak)?$`),
+	regexp.MustCompile(`(^|/)MANIFEST(-\d+)?$`),
+	regexp.MustCompile(`(^|/)OPTIONS(-\d+)?$`),
+	regexp.MustCompile(`(^|/)LOG(\.old)?$`),
+	regexp.MustCompile(`(^|/)\d{6}\.log$`),
+}
+
+func shouldIgnore(rel string) bool {
+	rel = strings.TrimPrefix(rel, "./")
+	rel = strings.TrimSuffix(rel, "/")
+	for _, re := range ignoreRE {
+		if re.MatchString(rel) {
+			return true
+		}
+		// also check just the base name for convenience
+		if re.MatchString(path.Base(rel)) {
+			return true
+		}
+	}
+	return false
+}
+
+func HashDirParallel(root string) (string, error) {
+	files, err := dirhash.DirFiles(root, "")
+
+	if err != nil {
+		return "", err
+	}
+
+	// Ignore all files like logs which we dont want to hash
+	filesList := make([]string, 0, len(files))
+	for _, f := range files {
+		if shouldIgnore(f) {
+			continue
+		}
+		if strings.Contains(f, "\n") {
+			return "", errors.New("dirhash: filenames with newlines are not supported")
+		}
+		filesList = append(filesList, f)
+	}
+
+	// Sort for deterministic ordering
+	sort.Strings(filesList)
+
+	filesLength := len(filesList)
+
+	hashes := make([][32]byte, filesLength)
+
+	// Number of CPUs determine the number of workers for our files
+	workers := runtime.NumCPU()
+
+	// create a channel for each file
+	filesToProcessJobs := make(chan int, filesLength)
+
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+	var errorProcessingFile error
+
+	// Each worker should call processFile to process files from the channel
+	for i := 0; i < workers; i++ {
+		wg.Add(1)
+		go processFileForHashing(filesToProcessJobs, filesList, root, hashes, &wg, &mu, &errorProcessingFile)
+	}
+
+	for i := 0; i < filesLength; i++ {
+		filesToProcessJobs <- i
+	}
+
+	// After the last sent value is returned, close all the channels
+	close(filesToProcessJobs)
+	// wait for all workers to finish
+	wg.Wait()
+
+	// if any worker encountered an error, return it
+	if errorProcessingFile != nil {
+		return "", errorProcessingFile
+	}
+
+	h := sha256.New()
+	for i, file := range filesList {
+		fmt.Fprintf(h, "%x  %s\n", hashes[i], file)
+	}
+
+	return "h1:" + base64.StdEncoding.EncodeToString(h.Sum(nil)), nil
+}
+
+func processFileForHashing(filesToProcessJobs chan int, filesList []string, root string, hashes [][32]byte, wg *sync.WaitGroup, mu *sync.Mutex, errorProcessingFile *error) {
+	defer wg.Done()
+	fileBuffer := make([]byte, 512*1024) // 512 KB buffer
+
+	for fileIndex := range filesToProcessJobs {
+		fileName := filesList[fileIndex]
+		f, err := os.Open(filepath.Join(root, filepath.FromSlash(fileName)))
+		if err != nil {
+			mu.Lock()
+			if *errorProcessingFile == nil {
+				*errorProcessingFile = err
+			}
+			mu.Unlock()
+			return
+		}
+
+		hasher := sha256.New()
+		_, err = io.CopyBuffer(hasher, f, fileBuffer)
+		if err != nil {
+			mu.Lock()
+			if *errorProcessingFile == nil {
+				*errorProcessingFile = err
+			}
+			mu.Unlock()
+			f.Close()
+			return
+		}
+		err = f.Close()
+		if err != nil {
+			mu.Lock()
+			if *errorProcessingFile == nil {
+				*errorProcessingFile = err
+			}
+			mu.Unlock()
+			return
+		}
+
+		var hashArr [32]byte
+		copy(hashArr[:], hasher.Sum(nil))
+		hashes[fileIndex] = hashArr
+	}
+}
+
+// VerifySnapshot verifies the snapshot by first trying to verify the stored snapshot checksum
+// using the key manager public key. If that fails, it falls back to verifying the snapshot
+// checksum against the provided snapshotChecksum in the config. If the snapshot is verified using the
+// config snapshot checksum, it deletes the existing AuthTags ancient store to prepare for
+// new tags from the new enclave hash.
+// It returns true if the auth tags need to be re-initialized (which occurs when
+// the config snapshot checksum is used and there is no valid snapshot.txt file),
+// false otherwise.
+func VerifySnapshot(snapshotChecksum string, parentChainDir string, l2chainDataDir string, ancientDir string, privateKey *ecdsa.PrivateKey) (bool, error) {
+	pubKey := &privateKey.PublicKey
+	// Check if snapshot verification is required or not
+	// Check if snapshot.txt file exists along with a valid snapshot_signature.txt
+	path := filepath.Join(parentChainDir, "snapshot_verified.txt")
+	snapshotVerifiedSignature, err := os.ReadFile(path)
+	if err == nil {
+		// Verify the signature
+		err = VerifyMessage([]byte("snapshot verified"), snapshotVerifiedSignature, pubKey)
+		if err != nil {
+			return false, fmt.Errorf("failed to verify snapshot verified signature: %w", err)
+		}
+		log.Info("Snapshot has already been verified previously")
+		return false, nil
+	}
+
+	sha256Hash, err := HashDirParallel(l2chainDataDir)
+	if err != nil {
+		return false, err
+	}
+
+	// Check if the snapshot hash matches the one in the config
+	if snapshotChecksum != sha256Hash {
+		return false, fmt.Errorf("snapshot hash mismatch, want: %s, got: %s", sha256Hash, snapshotChecksum)
+	}
+	log.Info("Snapshot hash matches", "hash", sha256Hash)
+
+	// Here we are deleting the `AuthTags` ancient store because we want to replace it with new tags
+	// from the new enclave hash. We cant just overwrite the existing tags because freezer doesnt allow
+	// you to modify the tags of an existing freezer.
+	tagFreezerDir := filepath.Join(ancientDir, "auth-tags")
+	err = os.RemoveAll(tagFreezerDir)
+	if err != nil {
+		return false, fmt.Errorf("failed to delete authtag ancient store: %w", err)
+	}
+
+	err = StoreSnapshotVerified(parentChainDir, privateKey)
+	if err != nil {
+		return false, fmt.Errorf("failed to store snapshot verified signature: %w", err)
+	}
+
+	return true, nil
+}
+
+func StoreSnapshotVerified(parentChainDir string, privKey *ecdsa.PrivateKey) error {
+	// Store the signature in snapshot_verified.txt to avoid re-verifying in future
+	signature, err := SignMessage([]byte("snapshot verified"), privKey)
+	if err != nil {
+		return fmt.Errorf("failed to sign snapshot verified message: %w", err)
+	}
+	path := filepath.Join(parentChainDir, "snapshot_verified.txt")
+
+	file, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("failed to create snapshot verified file: %w", err)
+	}
+	defer file.Close()
+	_, err = file.Write(signature)
+	if err != nil {
+		return fmt.Errorf("failed to write snapshot verified file: %w", err)
+	}
+	log.Info("Stored the snapshot verified signature in a file", "path", path)
+	return nil
+}
+
+func SignMessage(message []byte, privKey *ecdsa.PrivateKey) ([]byte, error) {
+	hash := crypto.Keccak256Hash(message)
+	return crypto.Sign(hash.Bytes(), privKey)
+}
+
+func VerifyMessage(message []byte, signature []byte, pubKey *ecdsa.PublicKey) error {
+	if pubKey == nil {
+		return errors.New("public key is nil")
+	}
+	hash := crypto.Keccak256Hash(message)
+	sigPublicKey, err := crypto.SigToPub(hash.Bytes(), signature)
+	if err != nil {
+		return fmt.Errorf("failed to recover public key from signature: %w", err)
+	}
+	sigAddress := crypto.PubkeyToAddress(*sigPublicKey)
+	expectedAddress := crypto.PubkeyToAddress(*pubKey)
+	if sigAddress != expectedAddress {
+		return fmt.Errorf("signature verification failed: expected address %s, got %s", expectedAddress.Hex(), sigAddress.Hex())
+	}
+	return nil
+}
+
+// StripHexPrefix removes "0x" prefix from hex strings if present
+func StripHexPrefix(hexStr string) string {
+	if len(hexStr) >= 2 && hexStr[:2] == "0x" {
+		return hexStr[2:]
+	}
+	return hexStr
+}
diff --git a/arbutil/testdata/generate_rlp.go b/arbutil/testdata/generate_rlp.go
new file mode 100644
index 00000000000..6b1a78837b6
--- /dev/null
+++ b/arbutil/testdata/generate_rlp.go
@@ -0,0 +1,37 @@
+package main
+
+import (
+	"log"
+	"os"
+
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+// MessageIndex is an alias for backward compatibility testing.
+type MessageIndex uint64
+
+// OldSubmittedEspressoTx represents the structure of the transaction before
+// the SubmittedAt field was added.
+type OldSubmittedEspressoTx struct {
+	Hash    string
+	Pos     []MessageIndex
+	Payload []byte
+}
+
+func main() {
+	oldSubmittedTx := OldSubmittedEspressoTx{
+		Hash:    "0x1234",
+		Pos:     []MessageIndex{MessageIndex(10)},
+		Payload: []byte{0, 1, 2, 3},
+	}
+
+	b, err := rlp.EncodeToBytes(&oldSubmittedTx)
+	if err != nil {
+		log.Fatalf("Failed to encode: %v", err)
+	}
+
+	err = os.WriteFile("arbutil/testdata/old_submitted_espresso_tx.rlp", b, 0644)
+	if err != nil {
+		log.Fatalf("Failed to write artifact file: %v", err)
+	}
+}
diff --git a/arbutil/testdata/old_submitted_espresso_tx.md b/arbutil/testdata/old_submitted_espresso_tx.md
new file mode 100644
index 00000000000..4238d75ff27
--- /dev/null
+++ b/arbutil/testdata/old_submitted_espresso_tx.md
@@ -0,0 +1,13 @@
+# Old Submitted Espresso Tx RLP Artifact
+
+This directory contains an RLP-encoded data artifact for the `OldSubmittedEspressoTx` struct for backward compatibility testing.
+
+The old struct format can be found at [this commit](https://github.com/EspressoSystems/nitro-espresso-integration/blob/b8c11f3cdb91893f8c1109872f7c46eb6f82e57d/arbutil/espresso_utils.go#L19).
+
+The file `old_submitted_espresso_tx.rlp` was generated using the Go code in file `generate_rlp.go`.
+
+You can regenerate the file by running:
+
+```sh
+go run arbutil/testdata/generate_rlp.go
+```
diff --git a/arbutil/testdata/old_submitted_espresso_tx.rlp b/arbutil/testdata/old_submitted_espresso_tx.rlp
new file mode 100644
index 00000000000..63771eedae4
Binary files /dev/null and b/arbutil/testdata/old_submitted_espresso_tx.rlp differ
diff --git a/bold/assertions/poster_test.go b/bold/assertions/poster_test.go
index aaba9f71e61..cd15a8ef2ff 100644
--- a/bold/assertions/poster_test.go
+++ b/bold/assertions/poster_test.go
@@ -18,12 +18,13 @@ import (
 	gethtypes "github.com/ethereum/go-ethereum/core/types"
 
 	"github.com/offchainlabs/nitro/bold/assertions"
-	"github.com/offchainlabs/nitro/bold/chain-abstraction"
-	"github.com/offchainlabs/nitro/bold/challenge-manager"
+	protocol "github.com/offchainlabs/nitro/bold/chain-abstraction"
+	challengemanager "github.com/offchainlabs/nitro/bold/challenge-manager"
 	"github.com/offchainlabs/nitro/bold/challenge-manager/types"
-	"github.com/offchainlabs/nitro/bold/testing"
-	"github.com/offchainlabs/nitro/bold/testing/mocks/state-provider"
+	challenge_testing "github.com/offchainlabs/nitro/bold/testing"
+	stateprovider "github.com/offchainlabs/nitro/bold/testing/mocks/state-provider"
 	"github.com/offchainlabs/nitro/bold/testing/setup"
+	testutils "github.com/offchainlabs/nitro/espresso/test-utils"
 	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
 	"github.com/offchainlabs/nitro/solgen/go/mocksgen"
 	"github.com/offchainlabs/nitro/solgen/go/rollupgen"
@@ -194,8 +195,8 @@ func forceSequencerMessageBatchPosting(
 	seqNum.Sub(seqNum, common.Big1)
 	seqInbox, err := bridgegen.NewSequencerInbox(seqInboxAddr, backend)
 	require.NoError(t, err)
-	tx, err := seqInbox.AddSequencerL2BatchFromOrigin8f111f3c(
-		sequencerOpts, seqNum, message, big.NewInt(1), common.Address{}, big.NewInt(0), big.NewInt(0),
+	tx, err := seqInbox.AddSequencerL2BatchFromOrigin37501551(
+		sequencerOpts, seqNum, message, big.NewInt(1), common.Address{}, big.NewInt(0), big.NewInt(0), testutils.CreateDummyEspressoMetadata(t),
 	)
 	require.NoError(t, err)
 	require.NoError(t, challenge_testing.WaitForTx(ctx, backend, tx))
diff --git a/bold/testing/endtoend/backend/anvil_local.go b/bold/testing/endtoend/backend/anvil_local.go
index 01cbdedabf1..26d1ce13a20 100644
--- a/bold/testing/endtoend/backend/anvil_local.go
+++ b/bold/testing/endtoend/backend/anvil_local.go
@@ -237,6 +237,7 @@ func (a *AnvilLocal) DeployRollup(ctx context.Context, opts ...challenge_testing
 			genesisExecutionState,
 			genesisInboxCount,
 			anyTrustFastConfirmer,
+			common.Address{},
 			opts...,
 		),
 		setup.RollupStackConfig{
diff --git a/bold/testing/rollup_config.go b/bold/testing/rollup_config.go
index 91ee67c7107..2e8cfd14926 100644
--- a/bold/testing/rollup_config.go
+++ b/bold/testing/rollup_config.go
@@ -71,6 +71,7 @@ func GenerateRollupConfig(
 	genesisExecutionState rollupgen.AssertionState,
 	genesisInboxCount *big.Int,
 	anyTrustFastConfirmer common.Address,
+	espressoTEEAddr common.Address,
 	opts ...Opt,
 ) rollupgen.Config {
 	var confirmPeriod uint64
@@ -113,6 +114,8 @@ func GenerateRollupConfig(
 		AnyTrustFastConfirmer:        anyTrustFastConfirmer,
 		NumBigStepLevel:              1,
 		ChallengeGracePeriodBlocks:   gracePeriod,
+
+		EspressoTEEVerifier: espressoTEEAddr,
 	}
 	for _, o := range opts {
 		o(&cfg)
diff --git a/bold/testing/setup/rollup_stack.go b/bold/testing/setup/rollup_stack.go
index 642d18a6ba5..f06a5f366ae 100644
--- a/bold/testing/setup/rollup_stack.go
+++ b/bold/testing/setup/rollup_stack.go
@@ -24,12 +24,13 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rpc"
 
-	"github.com/offchainlabs/nitro/bold/chain-abstraction"
-	"github.com/offchainlabs/nitro/bold/chain-abstraction/sol-implementation"
-	"github.com/offchainlabs/nitro/bold/layer2-state-provider"
-	"github.com/offchainlabs/nitro/bold/runtime"
-	"github.com/offchainlabs/nitro/bold/testing"
-	"github.com/offchainlabs/nitro/bold/testing/mocks/state-provider"
+	protocol "github.com/offchainlabs/nitro/bold/chain-abstraction"
+	solimpl "github.com/offchainlabs/nitro/bold/chain-abstraction/sol-implementation"
+	l2stateprovider "github.com/offchainlabs/nitro/bold/layer2-state-provider"
+	retry "github.com/offchainlabs/nitro/bold/runtime"
+	challenge_testing "github.com/offchainlabs/nitro/bold/testing"
+	stateprovider "github.com/offchainlabs/nitro/bold/testing/mocks/state-provider"
+	"github.com/offchainlabs/nitro/espresso-tee-contracts/espressogen"
 	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
 	"github.com/offchainlabs/nitro/solgen/go/challengeV2gen"
 	"github.com/offchainlabs/nitro/solgen/go/contractsgen"
@@ -300,6 +301,11 @@ func ChainsWithEdgeChallengeManager(opts ...Opt) (*ChainSetup, error) {
 		}
 		accs[0].TxOpts.Value = big.NewInt(0)
 	}
+	//  Deploy a espressoTEEVerifierMock contract
+	espressoTEEVerifierAddress, tx, _, err := espressogen.DeployEspressoTEEVerifierMock(accs[0].TxOpts, backend, common.HexToAddress("0x2"))
+	if err != nil {
+		return nil, err
+	}
 
 	prod := false
 	wasmModuleRoot := common.Hash{}
@@ -394,6 +400,7 @@ func ChainsWithEdgeChallengeManager(opts ...Opt) (*ChainSetup, error) {
 		genesisExecutionState,
 		genesisInboxCount,
 		anyTrustFastConfirmer,
+		espressoTEEVerifierAddress,
 		setp.challengeTestingOpts...,
 	)
 	addresses, err := DeployFullRollupStack(
diff --git a/broadcastclient/broadcastclient.go b/broadcastclient/broadcastclient.go
index 5a28b09f0c5..75f862bfda7 100644
--- a/broadcastclient/broadcastclient.go
+++ b/broadcastclient/broadcastclient.go
@@ -4,6 +4,7 @@
 package broadcastclient
 
 import (
+	"bufio"
 	"context"
 	"crypto/tls"
 	"encoding/json"
@@ -12,6 +13,7 @@ import (
 	"io"
 	"net"
 	"net/http"
+	"net/url"
 	"strconv"
 	"strings"
 	"sync"
@@ -22,6 +24,7 @@ import (
 	"github.com/gobwas/ws"
 	"github.com/gobwas/ws/wsflate"
 	"github.com/spf13/pflag"
+	"golang.org/x/net/proxy"
 
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
@@ -221,6 +224,107 @@ func (bc *BroadcastClient) Start(ctxIn context.Context) {
 	})
 }
 
+// In the case where there is a proxy setup
+// Connect to proxy first, then make request to address through proxy.
+func (bc *BroadcastClient) connectWithProxy(
+	ctx context.Context,
+	dialer net.Dialer,
+	proxyURL *url.URL,
+	addr string,
+) (net.Conn, error) {
+	// Connect to proxy
+	var conn net.Conn
+	var err error
+	switch proxyURL.Scheme {
+	case "https":
+		tlsDialer := &tls.Dialer{
+			Config: &tls.Config{
+				MinVersion: tls.VersionTLS12,
+			},
+		}
+		conn, err = tlsDialer.DialContext(ctx, "tcp4", proxyURL.Host)
+		if err != nil {
+			log.Warn("https proxy tcp4 connection failed, falling back to tcp6", "proxy", proxyURL.Host, "err", err)
+			conn, err = tlsDialer.DialContext(ctx, "tcp6", proxyURL.Host)
+			if err != nil {
+				return nil, err
+			}
+		}
+	case "http":
+		conn, err = dialer.DialContext(ctx, "tcp4", proxyURL.Host)
+		if err != nil {
+			log.Warn("http proxy tcp4 connection failed, falling back to tcp6", "proxy", proxyURL.Host, "err", err)
+			conn, err = dialer.DialContext(ctx, "tcp6", proxyURL.Host)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+	case "socks5":
+		proxyDialer, err := proxy.FromURL(proxyURL, &net.Dialer{})
+		if err != nil {
+			return nil, fmt.Errorf("SOCKS5 setup failed: %w", err)
+		}
+		conn, err = proxyDialer.Dial("tcp4", addr)
+		if err != nil {
+			log.Warn("socks5 proxy tcp4 connection failed, falling back to tcp6", "proxy", proxyURL.Host, "err", err)
+			conn, err = proxyDialer.Dial("tcp6", addr)
+			if err != nil {
+				return nil, err
+			}
+		}
+		return conn, nil
+
+	default:
+		return nil, fmt.Errorf("unsupported proxy scheme: %s", proxyURL.Scheme)
+	}
+
+	// Connect to address through proxy
+	connectReq := &http.Request{
+		Method: "CONNECT",
+		URL:    &url.URL{Opaque: addr},
+		Host:   addr,
+		Header: make(http.Header),
+	}
+	if proxyURL.User != nil {
+		username := proxyURL.User.Username()
+		password, _ := proxyURL.User.Password()
+		connectReq.SetBasicAuth(username, password)
+	}
+
+	if deadline, ok := ctx.Deadline(); ok {
+		if err := conn.SetDeadline(deadline); err != nil {
+			conn.Close()
+			return nil, fmt.Errorf("%s proxy set deadline failed: %w", proxyURL.Scheme, err)
+		}
+		// clear deadline
+		defer func() {
+			if err := conn.SetDeadline(time.Time{}); err != nil {
+				log.Warn("Failed to clear deadline on %s proxy connection: %v", proxyURL.Scheme, err)
+			}
+		}()
+	}
+
+	if err := connectReq.Write(conn); err != nil {
+		conn.Close()
+		return nil, fmt.Errorf("http proxy connect to %s failed: %w", addr, err)
+	}
+
+	// Verify response
+	resp, err := http.ReadResponse(bufio.NewReader(conn), connectReq)
+	if err != nil {
+		conn.Close()
+		return nil, fmt.Errorf("http proxy response error: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != 200 {
+		conn.Close()
+		return nil, fmt.Errorf("http proxy refused: %s", resp.Status)
+	}
+
+	return conn, nil
+}
+
 func (bc *BroadcastClient) connect(ctx context.Context, nextSeqNum arbutil.MessageIndex) (io.Reader, error) {
 	if len(bc.websocketUrl) == 0 {
 		// Nothing to do
@@ -291,15 +395,24 @@ func (bc *BroadcastClient) connect(ctx context.Context, nextSeqNum arbutil.Messa
 		Extensions: extensions,
 		NetDial: func(ctx context.Context, network, addr string) (net.Conn, error) {
 			var netDialer net.Dialer
-			// For tcp connections, prefer IPv4 over IPv6 to avoid rate limiting issues
-			if network == "tcp" {
+			if network != "tcp" {
+				return netDialer.DialContext(ctx, network, addr)
+			}
+
+			// Check if we need to connect to proxy
+			req := &http.Request{URL: &url.URL{Scheme: "https", Host: addr}}
+			proxyURL, err := http.ProxyFromEnvironment(req)
+			// If no proxy is setup just connect to the addr
+			if err != nil || proxyURL == nil {
+				// For tcp connections, prefer IPv4 over IPv6 to avoid rate limiting issues
 				conn, err := netDialer.DialContext(ctx, "tcp4", addr)
 				if err == nil {
 					return conn, nil
 				}
+				log.Warn("failed to connect to ipv4 addr, failing back to tcp6", "addr", addr, "err", err)
 				return netDialer.DialContext(ctx, "tcp6", addr)
 			}
-			return netDialer.DialContext(ctx, network, addr)
+			return bc.connectWithProxy(ctx, netDialer, proxyURL, addr)
 		},
 	}
 
diff --git a/ci_skip_tests b/ci_skip_tests
new file mode 100644
index 00000000000..02d5e128f34
--- /dev/null
+++ b/ci_skip_tests
@@ -0,0 +1,76 @@
+# This file is used for filtering CI tests.
+# These tests are prone to fail in the CI
+# environment. To run tests locally, please run:
+# ```
+# ./scripts/espresso-ci-local
+# ```
+# To see how we use this file, please check scripts/espresso-run-test-ci
+#
+# Note that if a substring of the test function name is listed here, it will be skipped.
+TestChallengeManagerFullAsserterCorrect
+TestChallengeManagerFullAsserterIncorrect
+TestLiveNodeConfig
+TestProgramActivateTwice
+TestProgramArbitratorEvmData
+TestProgramCallSimple
+TestProgramEvmData
+TestProgramLogs
+TestProgramLogsWithTracing
+TestRPCStore
+TestProgramTransientStorage
+TestProgramCalls
+TestProgramMemory
+TestProgramErrors
+TestPeriodicReloadOfLiveNodeConfig
+TestProgramLongArbitratorCall
+TestProgramArbitratorCalls
+TestProgramLongCall
+TestProgramArbitratorActivateTwice
+TestProgramArbitratorMemory
+TestProgramArbitratorLogs
+TestProgramArbitratorTransientStorage
+TestProgramArbitratorErrors
+TestBlockValidatorSimpleJITOnchain
+TestMockChallengeManagerAsserterIncorrect
+TestChallengeStakersFaultyHonestActive
+TestChallengeManagerFullAsserterCorrectWithPublishedMachine
+TestRedisProduce
+TestRedisSeqCoordinatorPrioritiesFlaky
+TestBlockValidatorSimpleOnchainWithPublishedMachine
+TestChallengeToFailedOSP
+TestChallengeToTimeout
+TestStylusUpgrade
+TestChallengeToFailedTooFar
+TestTwoNodesLong
+TestStylusOpcodeTraceEquivalence
+TestGettingState
+TestBatchPosterDelayBufferDisabled
+TestEthSyncing
+TestOutOfGasInStorageCacheFlush
+TestPrimaryToSecondaryFailover
+TestRetryableExpiry
+
+# These tests are skipped because of invalid long paths of temporary directory
+# in CI environment. Currently we don't have methods to modify the
+# `GITHUB_WORKSPACE` https://github.com/actions/runner/issues/1676
+# See: /system_tests/forwarder_test.go:tmpPath
+# https://github.com/ethereum/go-ethereum/issues/16342
+TestArbTraceForwarding
+TestIpcRpc
+TestRedisForwarder
+TestRedisForwarderFallbackNoRedis
+TestRequestForwardingToArchiveNodes
+TestStaticForwarder
+
+# This test is failing and it is a bit complicated.
+# Since BOLD is an alpha feature, we will fix it later
+TestChallengeProtocolBOLDNearLastVirtualBlock
+TestChallengeProtocolBOLDFirstVirtualBlock
+# These tests are specific to Espresso and we have a dedicated
+# CI workflow for them. See: .github/workflows/espresso-e2e.yml
+TestEspresso
+TestAuthDB
+
+# These tests are resource consuming. They will crash the github runner
+TestDimLogSstoreMultipleWarmZeroToNonZeroToNonZero
+TestDimTxOpCallColdPayingContractFundedMemUnchanged
diff --git a/cmd/deploy/deploy.go b/cmd/deploy/deploy.go
index 6a443240a7d..e417ef16b83 100644
--- a/cmd/deploy/deploy.go
+++ b/cmd/deploy/deploy.go
@@ -43,6 +43,7 @@ func main() {
 	deployAccount := flag.String("l1DeployAccount", "", "l1 seq account to use (default is first account in keystore)")
 	ownerAddressString := flag.String("ownerAddress", "", "the rollup owner's address")
 	sequencerAddressString := flag.String("sequencerAddress", "", "the sequencer's address")
+	espressoTEEVerifierAddressString := flag.String("espressoTEEVerifierAddress", "", "the address of the espressoTEEVerifier contract")
 	batchPostersString := flag.String("batchPosters", "", "the comma separated array of addresses of batch posters. Defaults to sequencer address")
 	batchPosterManagerAddressString := flag.String("batchPosterManger", "", "the batch poster manger's address. Defaults to owner address")
 	nativeTokenAddressString := flag.String("nativeTokenAddress", "0x0000000000000000000000000000000000000000", "address of the ERC20 token which is used as native L2 currency")
@@ -96,6 +97,11 @@ func main() {
 	if !common.IsHexAddress(*sequencerAddressString) && len(*sequencerAddressString) > 0 {
 		panic("specified sequencer address is invalid")
 	}
+
+	if !common.IsHexAddress(*espressoTEEVerifierAddressString) {
+		panic("specified espressoTEEVerifier address is invalid")
+	}
+	espressoTEEVerifierAddress := common.HexToAddress(*espressoTEEVerifierAddressString) // This might be unused as a result of using mergiraf the one time, it meant that the creation of the rollup config here no longer takes the tee verifier address. TODO
 	sequencerAddress := common.HexToAddress(*sequencerAddressString)
 
 	if !common.IsHexAddress(*ownerAddressString) {
@@ -107,6 +113,10 @@ func main() {
 		panic("please specify a valid loser escrow address")
 	}
 
+	if !common.IsHexAddress(*espressoTEEVerifierAddressString) {
+		panic("please specify a valid espresso tee verifier address")
+	}
+
 	var batchPosters []common.Address
 	if len(*batchPostersString) > 0 {
 		batchPostersArr := strings.Split(*batchPostersString, ",")
@@ -185,7 +195,7 @@ func main() {
 		batchPosters,
 		batchPosterManagerAddress,
 		*authorizevalidators,
-		deploy.GenerateLegacyRollupConfig(*prod, moduleRoot, ownerAddress, &chainConfig, chainConfigJson, loserEscrowAddress),
+		deploy.GenerateLegacyRollupConfig(*prod, moduleRoot, ownerAddress, &chainConfig, chainConfigJson, loserEscrowAddress, espressoTEEVerifierAddress),
 		nativeToken,
 		maxDataSize,
 		true,
diff --git a/cmd/genericconf/config.go b/cmd/genericconf/config.go
index cf32afb351f..978c04083e9 100644
--- a/cmd/genericconf/config.go
+++ b/cmd/genericconf/config.go
@@ -109,13 +109,18 @@ func FileLoggingConfigAddOptions(prefix string, f *pflag.FlagSet) {
 }
 
 type RpcConfig struct {
-	MaxBatchResponseSize int `koanf:"max-batch-response-size"`
-	BatchRequestLimit    int `koanf:"batch-request-limit"`
+	MaxBatchResponseSize             int    `koanf:"max-batch-response-size"`
+	BatchRequestLimit                int    `koanf:"batch-request-limit"`
+	EnableTeeIntegrityAttestation    bool   `koanf:"enable-tee-integrity-attestation"`
+	IntegrityKeyPairAttestationsPath string `koanf:"integrity-key-pair-attestations-path"`
 }
 
 var DefaultRpcConfig = RpcConfig{
 	MaxBatchResponseSize: 10_000_000, // 10MB
 	BatchRequestLimit:    node.DefaultConfig.BatchRequestLimit,
+
+	EnableTeeIntegrityAttestation:    false,
+	IntegrityKeyPairAttestationsPath: "integrity_key_pair_attestations",
 }
 
 func (c *RpcConfig) Apply(stackConf *node.Config) {
@@ -126,4 +131,6 @@ func (c *RpcConfig) Apply(stackConf *node.Config) {
 func RpcConfigAddOptions(prefix string, f *pflag.FlagSet) {
 	f.Int(prefix+".max-batch-response-size", DefaultRpcConfig.MaxBatchResponseSize, "the maximum response size for a JSON-RPC request measured in bytes (0 means no limit)")
 	f.Int(prefix+".batch-request-limit", DefaultRpcConfig.BatchRequestLimit, "the maximum number of requests in a batch (0 means no limit)")
+	f.Bool(prefix+".enable-tee-integrity-attestation", DefaultRpcConfig.EnableTeeIntegrityAttestation, "enable TEE integrity attestation")
+	f.String(prefix+".integrity-key-pair-attestations-path", DefaultRpcConfig.IntegrityKeyPairAttestationsPath, "path to integrity key pair attestations")
 }
diff --git a/cmd/nitro/config_test.go b/cmd/nitro/config_test.go
index cf290ae81cc..921c05d325f 100644
--- a/cmd/nitro/config_test.go
+++ b/cmd/nitro/config_test.go
@@ -37,6 +37,10 @@ func TestEmptyCliConfig(t *testing.T) {
 	if !reflect.DeepEqual(emptyCliNodeConfig, NodeConfigDefault) {
 		changelog, err := diff.Diff(emptyCliNodeConfig, NodeConfigDefault)
 		Require(t, err)
+		// TODO: Changes empty but some interfaces or pointer differs
+		if len(changelog) == 0 {
+			return
+		}
 		Fail(t, "empty cli config differs from expected default", changelog)
 	}
 }
diff --git a/cmd/nitro/nitro.go b/cmd/nitro/nitro.go
index 710cf3178ad..c2e6a2409e3 100644
--- a/cmd/nitro/nitro.go
+++ b/cmd/nitro/nitro.go
@@ -9,7 +9,9 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"errors"
+	"flag"
 	"fmt"
+	"hash"
 	"io"
 	"math/big"
 	"os"
@@ -55,6 +57,7 @@ import (
 	"github.com/offchainlabs/nitro/cmd/genericconf"
 	"github.com/offchainlabs/nitro/cmd/util"
 	"github.com/offchainlabs/nitro/cmd/util/confighelpers"
+	espresso_tee_utils "github.com/offchainlabs/nitro/cmd/util/espresso-tee-utils"
 	"github.com/offchainlabs/nitro/daprovider"
 	"github.com/offchainlabs/nitro/daprovider/das"
 	"github.com/offchainlabs/nitro/execution/gethexec"
@@ -224,6 +227,7 @@ func mainImpl() int {
 	}
 
 	var dataSigner signature.DataSignerFunc
+	var teeHMAC hash.Hash
 	var l1TransactionOptsValidator *bind.TransactOpts
 	var l1TransactionOptsBatchPoster *bind.TransactOpts
 	// If sequencer and signing is enabled or batchposter is enabled without
@@ -244,6 +248,51 @@ func mainImpl() int {
 	defaultBatchPosterL1WalletConfig := arbnode.DefaultBatchPosterL1WalletConfig
 	defaultBatchPosterL1WalletConfig.ResolveDirectoryNames(nodeConfig.Persistent.Chain)
 
+	nodeConfig.Node.Espresso.CaffNode.ResolveDirectoryNames(nodeConfig.Persistent.Chain)
+
+	var espressoCaffNodeInitArgs *arbnode.EspressoCaffNodeInitArgs
+
+	if nodeConfig.Node.Espresso.CaffNode.Enable && nodeConfig.Node.Espresso.CaffNode.TeeType != "" {
+		caffNodePrivateKey, err := espresso_tee_utils.ReadEnclavePrivateKey(nodeConfig.Node.Espresso.CaffNode.KeyPairAttestationsPath, nodeConfig.Chain.ID)
+		if err != nil {
+			flag.Usage()
+			log.Crit("error reading enclave private key for Espresso Caff node", "path", nodeConfig.Node.Espresso.CaffNode.KeyPairAttestationsPath, "err", err)
+		}
+
+		teeHMAC, err = espresso_tee_utils.DeriveHmac(nodeConfig.Node.Espresso.CaffNode.KeyPairAttestationsPath, nodeConfig.Chain.ID)
+		if err != nil {
+			flag.Usage()
+			log.Crit("error generating HMAC key for Espresso Caff node", "err", err)
+		}
+		privHex := hex.EncodeToString(caffNodePrivateKey.D.Bytes())
+
+		//
+		// This will be used by the hyperlane validator
+		os.Setenv("VALIDATOR_KEY", privHex)
+
+		// Use top-level wallet config, with env variable as fallback
+		caffNodeWallet := nodeConfig.EspressoCaffNodeWallet
+		if envPrivateKey := os.Getenv("ESPRESSO_CAFF_NODE_WALLET_PRIVATE_KEY"); envPrivateKey != "" {
+			caffNodeWallet.PrivateKey = envPrivateKey
+			log.Info("Using Espresso Caff Node private key from environment variable")
+		}
+
+		caffNodetxOpts, _, err := util.OpenWallet("l1-espresso-caff-node", &caffNodeWallet, new(big.Int).SetUint64(nodeConfig.ParentChain.ID))
+		if err != nil {
+			flag.Usage()
+			log.Crit("error opening Espresso Caff Node parent chain wallet", "path", caffNodeWallet.Pathname, "account", caffNodeWallet.Account, "err", err)
+		}
+		if caffNodeWallet.OnlyCreateKey {
+			return 0
+		}
+		espressoCaffNodeInitArgs = &arbnode.EspressoCaffNodeInitArgs{
+			InitializeCaffNodeTags: false,
+			CaffNodePrivateKey:     caffNodePrivateKey,
+			CaffNodetxOpts:         caffNodetxOpts,
+			TeeHMAC:                teeHMAC,
+		}
+	}
+
 	if sequencerNeedsKey || nodeConfig.Node.BatchPoster.ParentChainWallet.OnlyCreateKey {
 		l1TransactionOptsBatchPoster, dataSigner, err = util.OpenWallet("l1-batch-poster", &nodeConfig.Node.BatchPoster.ParentChainWallet, new(big.Int).SetUint64(nodeConfig.ParentChain.ID))
 		if err != nil {
@@ -443,6 +492,23 @@ func mainImpl() int {
 		return 1
 	}
 
+	var initializeCaffNodeTags bool
+	// If snapshot mode is enabled, verify the extracted snapshot hash matches the config
+	if nodeConfig.Node.Espresso.CaffNode.Enable && nodeConfig.Node.Espresso.CaffNode.SnapshotChecksum != "" {
+		// Check that TEE is enabled
+		if nodeConfig.Node.Espresso.CaffNode.TeeType == "" {
+			log.Error("snapshot verification requires TEE, but no TEE type was specified")
+			return 1
+		}
+		log.Info("Verifying the snapshot", "snapshot checksum", nodeConfig.Node.Espresso.CaffNode.SnapshotChecksum)
+		initializeCaffNodeTags, err = arbutil.VerifySnapshot(nodeConfig.Node.Espresso.CaffNode.SnapshotChecksum, stack.InstanceDir(), stack.ResolvePath("l2chaindata"), stack.ResolveAncient("l2chaindata", nodeConfig.Persistent.Ancient), espressoCaffNodeInitArgs.CaffNodePrivateKey)
+		if err != nil {
+			log.Error("failed to verify snapshot", "err", err)
+			return 1
+		}
+		espressoCaffNodeInitArgs.InitializeCaffNodeTags = initializeCaffNodeTags
+	}
+
 	chainDb, l2BlockChain, err := openInitializeChainDb(ctx, stack, nodeConfig, new(big.Int).SetUint64(nodeConfig.Chain.ID), gethexec.DefaultCacheConfigFor(&nodeConfig.Execution.Caching), &nodeConfig.Execution.StylusTarget, tracer, &nodeConfig.Persistent, l1Client, rollupAddrs)
 	if l2BlockChain != nil {
 		deferFuncs = append(deferFuncs, func() { l2BlockChain.Stop() })
@@ -554,6 +620,7 @@ func mainImpl() int {
 		execNode,
 		execNode,
 		arbDb,
+		chainDb,
 		&ConsensusNodeConfigFetcher{liveNodeConfig},
 		l2BlockChain.Config(),
 		l1Client,
@@ -565,6 +632,7 @@ func mainImpl() int {
 		new(big.Int).SetUint64(nodeConfig.ParentChain.ID),
 		blobReader,
 		wasmModuleRoot,
+		espressoCaffNodeInitArgs,
 	)
 	if err != nil {
 		log.Error("failed to create node", "err", err)
@@ -764,6 +832,7 @@ type NodeConfig struct {
 	Rpc                    genericconf.RpcConfig           `koanf:"rpc"`
 	BlocksReExecutor       blocksreexecutor.Config         `koanf:"blocks-reexecutor"`
 	EnsureRollupDeployment bool                            `koanf:"ensure-rollup-deployment" reload:"hot"`
+	EspressoCaffNodeWallet genericconf.WalletConfig        `koanf:"espresso-caff-node-wallet"`
 }
 
 var NodeConfigDefault = NodeConfig{
@@ -790,6 +859,7 @@ var NodeConfigDefault = NodeConfig{
 	PprofCfg:               genericconf.PProfDefault,
 	BlocksReExecutor:       blocksreexecutor.DefaultConfig,
 	EnsureRollupDeployment: true,
+	EspressoCaffNodeWallet: genericconf.WalletConfigDefault,
 }
 
 func NodeConfigAddOptions(f *pflag.FlagSet) {
@@ -817,6 +887,7 @@ func NodeConfigAddOptions(f *pflag.FlagSet) {
 	genericconf.RpcConfigAddOptions("rpc", f)
 	blocksreexecutor.ConfigAddOptions("blocks-reexecutor", f)
 	f.Bool("ensure-rollup-deployment", NodeConfigDefault.EnsureRollupDeployment, "before starting the node, wait until the transaction that deployed rollup is finalized")
+	genericconf.WalletConfigAddOptions("espresso-caff-node-wallet", f, "")
 }
 
 func (c *NodeConfig) ResolveDirectoryNames() error {
@@ -825,6 +896,7 @@ func (c *NodeConfig) ResolveDirectoryNames() error {
 		return err
 	}
 	c.Chain.ResolveDirectoryNames(c.Persistent.Chain)
+	c.EspressoCaffNodeWallet.ResolveDirectoryNames(c.Persistent.Chain)
 
 	return nil
 }
diff --git a/cmd/util/espresso-tee-utils/attestations.go b/cmd/util/espresso-tee-utils/attestations.go
new file mode 100644
index 00000000000..66a177424bc
--- /dev/null
+++ b/cmd/util/espresso-tee-utils/attestations.go
@@ -0,0 +1,212 @@
+package espresso_tee_utils
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"fmt"
+	"os"
+	"path"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/kms"
+	kmstypes "github.com/aws/aws-sdk-go-v2/service/kms/types"
+	"github.com/distributed-lab/enclave-extras/nsm"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+const (
+	// Attestation document with the KMS Key ID
+	// in UserData attestation doc field.
+	kmsKeyIDFile = "kms_key_id.coses1"
+	// Attestation document with the encrypted
+	// private key in UserData attestation doc field.
+	privateKeyFile = "private_key.coses1"
+	// Attestation document with the public key in
+	// UserData and PublicKey attestation doc fields.
+	publicKeyFile = "public_key.coses1"
+	// Attestation document with the Ethereum
+	// address in UserData attestation doc field.
+	addressFile = "address.coses1"
+)
+
+func GetAttestedKMSKeyID(cfg aws.Config, attestationsPath string, chainID uint64) (string, error) {
+	kmsKeyIDPath := path.Join(attestationsPath, kmsKeyIDFile)
+
+	kmsKeyIDAttestationDocRaw, err := os.ReadFile(kmsKeyIDPath)
+	// if attestation document exist just read KMS Key ID
+	if err == nil {
+		kmsKeyIDAttestationDoc, err := parseAndVerifyAttestationDocument(kmsKeyIDAttestationDocRaw)
+		if err != nil {
+			return "", fmt.Errorf("failed to parse %s: %w", kmsKeyIDPath, err)
+		}
+
+		return string(kmsKeyIDAttestationDoc.UserData), nil
+	}
+
+	// if attestation document exists, but we can't open file
+	if !os.IsNotExist(err) {
+		return "", fmt.Errorf("failed to read %s, check file permissions. err: %w", kmsKeyIDPath, err)
+	}
+
+	rootArn, principalArn, err := GetArns(cfg)
+	if err != nil {
+		return "", fmt.Errorf("failed to get root and principal arns for kms key policy: %w", err)
+	}
+
+	kmsEnclaveClient, err := GetKMSEnclaveClient(cfg)
+	if err != nil {
+		return "", fmt.Errorf("failed to get kms enclave client: %w", err)
+	}
+
+	_, pcr0Actual, err := nsm.DescribePCR(0)
+	if err != nil {
+		return "", fmt.Errorf("failed to get PCR0: %w", err)
+	}
+
+	kmsKeyPolicy := DefaultPolicies(rootArn, principalArn, map[int][]byte{0: pcr0Actual})
+	time := time.Now()
+	descriptionString := fmt.Sprintf("Nitro Enclave Key, Chain: %v, Date: %v", chainID, time.String())
+	createKeyOutput, err := kmsEnclaveClient.CreateKey(context.Background(), &kms.CreateKeyInput{
+		// DANGER: The key may become unmanageable
+		BypassPolicyLockoutSafetyCheck: true,
+		Description:                    &descriptionString,
+		Policy:                         aws.String(kmsKeyPolicy),
+	})
+	if err != nil {
+		return "", fmt.Errorf("failed to create KMS key: %w", err)
+	}
+
+	kmsKeyID := deref(createKeyOutput.KeyMetadata.KeyId)
+
+	// Save KMS Key
+	kmsKeyIDAttestationDocRaw, err = nsm.GetAttestationDoc([]byte(kmsKeyID), nil, nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to get attestation document for %s: %w", kmsKeyIDPath, err)
+	}
+	if err = os.WriteFile(kmsKeyIDPath, kmsKeyIDAttestationDocRaw, 0600); err != nil {
+		return "", fmt.Errorf("failed to write %s: %w", kmsKeyIDPath, err)
+	}
+
+	return kmsKeyID, nil
+}
+
+func GetAttestedPrivateKey(cfg aws.Config, kmsKeyID string, attestationsPath string) (*ecdsa.PrivateKey, error) {
+	kmsEnclaveClient, err := GetKMSEnclaveClient(cfg)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get kms enclave client: %w", err)
+	}
+
+	privateKeyPath := path.Join(attestationsPath, privateKeyFile)
+	privateKeyAttestationDocRaw, err := os.ReadFile(privateKeyPath)
+	// if attestation document exist just read and decrypt private key
+	if err == nil {
+		privateKeyAttestationDoc, err := parseAndVerifyAttestationDocument(privateKeyAttestationDocRaw)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse %s: %w", privateKeyPath, err)
+		}
+
+		decryptResp, err := kmsEnclaveClient.Decrypt(context.Background(), &kms.DecryptInput{
+			KeyId:          aws.String(kmsKeyID),
+			CiphertextBlob: privateKeyAttestationDoc.UserData,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("failed to decrypt private key: %w", err)
+		}
+
+		privateKey, err := parsePKCS8ECPrivateKey(decryptResp.Plaintext)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse secp256k1: %w", err)
+		}
+
+		return privateKey, nil
+	}
+
+	// if attestation document exists, but we can't open file
+	if !os.IsNotExist(err) {
+		return nil, fmt.Errorf("failed to read %s, check file permissions. err: %w", privateKeyPath, err)
+	}
+
+	// Create private key
+	generateDataKeyPairResp, err := kmsEnclaveClient.GenerateDataKeyPair(context.Background(), &kms.GenerateDataKeyPairInput{
+		KeyId:       aws.String(kmsKeyID),
+		KeyPairSpec: kmstypes.DataKeyPairSpecEccSecgP256k1,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to generate secp256k1 in KMS: %w", err)
+	}
+
+	privateKey, err := parsePKCS8ECPrivateKey(generateDataKeyPairResp.PrivateKeyPlaintext)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse secp256k1: %w", err)
+	}
+
+	// Save private key
+	privateKeyAttestationDocRaw, err = nsm.GetAttestationDoc(generateDataKeyPairResp.PrivateKeyCiphertextBlob, nil, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get attestation doc for %s: %w", privateKeyPath, err)
+	}
+	if err = os.WriteFile(privateKeyPath, privateKeyAttestationDocRaw, 0600); err != nil {
+		return nil, fmt.Errorf("failed to write %s: %w", privateKeyPath, err)
+	}
+
+	return privateKey, nil
+}
+
+func GetAttestedPublicKey(privateKey *ecdsa.PrivateKey, attestationsPath string) (*ecdsa.PublicKey, error) {
+	publicKeyPath := path.Join(attestationsPath, publicKeyFile)
+
+	// if attestation document exist just read public key
+	_, err := os.ReadFile(publicKeyPath)
+	if err == nil {
+		return &privateKey.PublicKey, nil
+	}
+
+	// if attestation document exists, but we can't open file
+	if !os.IsNotExist(err) {
+		return nil, fmt.Errorf("failed to read %s, check file permissions. err: %w", publicKeyPath, err)
+	}
+
+	publicKey := &privateKey.PublicKey
+
+	// Save public key
+	publicKeyAttestationDocRaw, err := nsm.GetAttestationDoc(crypto.FromECDSAPub(publicKey), nil, crypto.FromECDSAPub(publicKey))
+	if err != nil {
+		return nil, fmt.Errorf("failed to get attestation doc for %s: %w", publicKeyPath, err)
+	}
+	if err = os.WriteFile(publicKeyPath, publicKeyAttestationDocRaw, 0600); err != nil {
+		return nil, fmt.Errorf("failed to write %s: %w", publicKeyPath, err)
+	}
+
+	return publicKey, nil
+}
+
+func GetAttestedAddress(publicKey *ecdsa.PublicKey, attestationsPath string) (common.Address, error) {
+	address := crypto.PubkeyToAddress(*publicKey)
+
+	addressPath := path.Join(attestationsPath, addressFile)
+
+	// if attestation document exist just read address
+	_, err := os.ReadFile(addressPath)
+	if err == nil {
+		return address, nil
+	}
+
+	// if attestation document exists, but we can't open file
+	if !os.IsNotExist(err) {
+		return address, fmt.Errorf("failed to read %s, check file permissions. err: %w", addressPath, err)
+	}
+
+	// Save address
+	addressAttestationDocRaw, err := nsm.GetAttestationDoc(address[:], nil, nil)
+	if err != nil {
+		return address, fmt.Errorf("failed to get attestation doc for %s: %w", addressPath, err)
+	}
+	if err = os.WriteFile(addressPath, addressAttestationDocRaw, 0600); err != nil {
+		return address, fmt.Errorf("failed to write %s: %w", addressPath, err)
+	}
+
+	return address, nil
+}
diff --git a/cmd/util/espresso-tee-utils/kms_key_policies.go b/cmd/util/espresso-tee-utils/kms_key_policies.go
new file mode 100644
index 00000000000..43768e557cf
--- /dev/null
+++ b/cmd/util/espresso-tee-utils/kms_key_policies.go
@@ -0,0 +1,63 @@
+package espresso_tee_utils
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+)
+
+// Return PCRx condition to be used when creating a KMS key
+func PcrXCondition(pcrIndex int) string {
+	return fmt.Sprintf("kms:RecipientAttestation:PCR%d", pcrIndex)
+}
+
+func DefaultPolicies(rootARN, principalARN string, pcrs map[int][]byte) string {
+	pcrConditions := make(map[string]string, len(pcrs))
+	for k, v := range pcrs {
+		pcrConditions[PcrXCondition(k)] = hex.EncodeToString(v)
+	}
+
+	defaultPolicy := map[string]interface{}{
+		"Version": "2012-10-17",
+		"Id":      "key-default-1",
+		"Statement": []map[string]interface{}{
+			{
+				"Sid":    "Allow access for Key Administrators",
+				"Effect": "Allow",
+				"Principal": map[string]interface{}{
+					"AWS": rootARN,
+				},
+				"Action": []string{
+					"kms:CancelKeyDeletion",
+					"kms:DescribeKey",
+					"kms:DisableKey",
+					"kms:EnableKey",
+					"kms:GetKeyPolicy",
+					"kms:ScheduleKeyDeletion",
+				},
+				"Resource": "*",
+			},
+			{
+				"Sid":    "Enable enclave",
+				"Effect": "Allow",
+				"Principal": map[string]interface{}{
+					"AWS": principalARN,
+				},
+				"Action": []string{
+					"kms:Decrypt",
+					"kms:GenerateRandom",
+					"kms:GenerateDataKey",
+					"kms:GenerateDataKeyPair",
+				},
+				"Resource": "*",
+				"Condition": map[string]interface{}{
+					"StringEqualsIgnoreCase": pcrConditions,
+				},
+			},
+		},
+	}
+
+	// should never panic
+	policy, _ := json.Marshal(defaultPolicy)
+	return string(policy)
+}
diff --git a/cmd/util/espresso-tee-utils/utils.go b/cmd/util/espresso-tee-utils/utils.go
new file mode 100644
index 00000000000..96e061bc68e
--- /dev/null
+++ b/cmd/util/espresso-tee-utils/utils.go
@@ -0,0 +1,237 @@
+package espresso_tee_utils
+
+import (
+	"bytes"
+	"context"
+	"crypto/ecdsa"
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/sha256"
+	"crypto/x509"
+	"fmt"
+	"hash"
+	"os"
+	"strings"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/aws/arn"
+	awsconfig "github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/credentials/ec2rolecreds"
+	"github.com/aws/aws-sdk-go-v2/feature/ec2/imds"
+	"github.com/aws/aws-sdk-go-v2/service/sts"
+	"github.com/distributed-lab/enclave-extras/attestation"
+	"github.com/distributed-lab/enclave-extras/attestedkms"
+	"github.com/distributed-lab/enclave-extras/nsm"
+	"golang.org/x/crypto/hkdf"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+const (
+	AwsIamServiceID = "iam"
+	AwsStsServiceID = "sts"
+)
+
+func EnsureArnIsIam(v string) (string, error) {
+	resourceArn, err := arn.Parse(v)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse resource ARN: %w", err)
+	}
+
+	// If ARN service already IAM just return it
+	if resourceArn.Service == AwsIamServiceID {
+		return v, nil
+	}
+
+	if resourceArn.Service != AwsStsServiceID || !strings.HasPrefix(resourceArn.Resource, "assumed-role/") {
+		return "", fmt.Errorf("unsuported conversion, can convert only STS assumed-role in IAM role")
+	}
+
+	resourceArn.Service = AwsIamServiceID
+	// Should never be out of range, because of AWS guarantee that role can't be empty string
+	resourceArn.Resource = "role/" + strings.Split(resourceArn.Resource, "/")[1]
+
+	return resourceArn.String(), nil
+}
+
+func ToRootArn(v string) (string, error) {
+	resourceArn, err := arn.Parse(v)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse resource ARN: %w", err)
+	}
+
+	resourceArn.Service = AwsIamServiceID
+	resourceArn.Resource = "root"
+
+	return resourceArn.String(), nil
+}
+
+func GetArns(cfg aws.Config) (rootArn string, principalArn string, err error) {
+	stsClient := sts.NewFromConfig(cfg)
+	callerIdentityResponse, err := stsClient.GetCallerIdentity(context.Background(), &sts.GetCallerIdentityInput{})
+	if err != nil {
+		return "", "", fmt.Errorf("failed to get caller identity: %w", err)
+	}
+
+	principalArn, err = EnsureArnIsIam(deref(callerIdentityResponse.Arn))
+	if err != nil {
+		return "", "", fmt.Errorf("failed to cast arn: %w", err)
+	}
+
+	rootArn, err = ToRootArn(principalArn)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to make root arn: %w", err)
+	}
+
+	return rootArn, principalArn, nil
+}
+
+func GetKMSEnclaveClient(cfg aws.Config) (*attestedkms.KMSEnclaveClient, error) {
+	privateKey, err := rsa.GenerateKey(rand.Reader, 4096)
+	if err != nil {
+		return nil, fmt.Errorf("failed to generate RSA private key: %w", err)
+	}
+
+	derEncodedPublicKey, err := x509.MarshalPKIXPublicKey(&privateKey.PublicKey)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal public key PKIX: %w", err)
+	}
+
+	attestationDoc, err := nsm.GetAttestationDoc(nil, nil, derEncodedPublicKey)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get attestation document: %w", err)
+	}
+
+	return attestedkms.NewFromConfig(cfg, attestationDoc, privateKey), nil
+}
+
+func loadInstanceProfileConfig(ctx context.Context) (aws.Config, error) {
+	imdsClient := imds.New(imds.Options{})
+
+	roleProvider := ec2rolecreds.New(func(o *ec2rolecreds.Options) {
+		o.Client = imdsClient
+	})
+
+	var region string
+	if r, err := imdsClient.GetRegion(ctx, &imds.GetRegionInput{}); err == nil {
+		region = r.Region
+	} else {
+		return aws.Config{}, fmt.Errorf("could not determine region from IMDS: %w", err)
+	}
+
+	return awsconfig.LoadDefaultConfig(
+		ctx,
+		awsconfig.WithRegion(region),
+		awsconfig.WithCredentialsProvider(aws.NewCredentialsCache(roleProvider)),
+	)
+}
+func ReadEnclavePrivateKey(attestationsPath string, chainID uint64) (*ecdsa.PrivateKey, error) {
+	if err := os.MkdirAll(attestationsPath, os.ModePerm); err != nil {
+		return nil, fmt.Errorf("failed to create attestations path directory %s with error: %w", attestationsPath, err)
+	}
+
+	awsConfig, err := loadInstanceProfileConfig(context.Background())
+	if err != nil {
+		return nil, fmt.Errorf("failed to load AWS config: %w", err)
+	}
+
+	kmsKeyID, err := GetAttestedKMSKeyID(awsConfig, attestationsPath, chainID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get attested KMS Key ID: %w", err)
+	}
+
+	privateKey, err := GetAttestedPrivateKey(awsConfig, kmsKeyID, attestationsPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get attested private key: %w", err)
+	}
+
+	return privateKey, nil
+}
+
+func ReadEnclaveAddress(attestationsPath string, chainID uint64) (*common.Address, error) {
+	privateKey, err := ReadEnclavePrivateKey(attestationsPath, chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	publicKey, err := GetAttestedPublicKey(privateKey, attestationsPath)
+	if err != nil || publicKey == nil {
+		return nil, fmt.Errorf("failed to get attested public key: %w", err)
+	}
+	publicKeyAddress := crypto.PubkeyToAddress(*publicKey)
+
+	return &publicKeyAddress, nil
+}
+
+// DeriveHmac derives an HMAC from the attested private key using HKDF.
+func DeriveHmac(attestationsPath string, chainID uint64) (hash.Hash, error) {
+	privateKey, err := ReadEnclavePrivateKey(attestationsPath, chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	return deriveHmac(privateKey), nil
+}
+
+func deriveHmac(privateKey *ecdsa.PrivateKey) hash.Hash {
+	hash := sha256.New
+	info := []byte("HMAC key derivation")
+
+	hkdf := hkdf.New(hash, crypto.FromECDSA(privateKey), nil, info)
+	hmacKey := make([]byte, hash().Size())
+	if _, err := hkdf.Read(hmacKey); err != nil {
+		panic(fmt.Sprintf("hkdf.Read failed: %v", err))
+	}
+
+	return hmac.New(hash, hmacKey)
+}
+func HmacForTest() (hash.Hash, error) {
+	hmacKey := []byte("testHmacKey")
+	return hmac.New(sha256.New, hmacKey), nil
+}
+
+func deref[T any](p *T) T {
+	if p != nil {
+		return *p
+	}
+	var zero T
+	return zero
+}
+
+func parsePKCS8ECPrivateKey(pcks8PrivateKey []byte) (*ecdsa.PrivateKey, error) {
+	privateKeyAny, err := attestedkms.ParsePKCS8PrivateKey(pcks8PrivateKey)
+	if err != nil {
+		return nil, err
+	}
+
+	privateKey, ok := privateKeyAny.(*ecdsa.PrivateKey)
+	if !ok {
+		return nil, fmt.Errorf("invalid EC private key")
+	}
+
+	return privateKey, nil
+}
+
+func parseAndVerifyAttestationDocument(rawDocument []byte) (*attestation.NSMAttestationDoc, error) {
+	attestationDoc, err := attestation.ParseNSMAttestationDoc(rawDocument)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse attestation document: %w", err)
+	}
+
+	if err = attestationDoc.Verify(); err != nil {
+		return nil, fmt.Errorf("attestation document have invalid signature: %w", err)
+	}
+
+	_, pcr0Actual, err := nsm.DescribePCR(0)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get PCR0: %w", err)
+	}
+
+	if pcr0Stored, ok := attestationDoc.PCRs[0]; !ok || !bytes.Equal(pcr0Stored, pcr0Actual) {
+		return nil, fmt.Errorf("PCR0 from attestation document mismatch with actual PCR0 value")
+	}
+
+	return attestationDoc, nil
+}
diff --git a/cmd/util/espresso-tee-utils/utils_test.go b/cmd/util/espresso-tee-utils/utils_test.go
new file mode 100644
index 00000000000..a584f9055d6
--- /dev/null
+++ b/cmd/util/espresso-tee-utils/utils_test.go
@@ -0,0 +1,61 @@
+package espresso_tee_utils
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+// TestDeriveHmacDeterministic verifies that deriveHmac always produces
+// the same HMAC key for the same ECDSA private key.
+func TestDeriveHmacDeterministic(t *testing.T) {
+	privateKey, err := crypto.GenerateKey()
+	if err != nil {
+		t.Fatalf("failed to generate test private key: %v", err)
+	}
+
+	hmac1 := deriveHmac(privateKey)
+	testMessage := []byte("test message")
+	hmac1.Write(testMessage)
+	sum1 := hmac1.Sum(nil)
+
+	hmac2 := deriveHmac(privateKey)
+	hmac2.Write(testMessage)
+	sum2 := hmac2.Sum(nil)
+
+	// Verify HMAC outputs are identical for the same private key and message
+	if !bytes.Equal(sum1, sum2) {
+		t.Errorf("HMAC outputs differ for the same private key and message.\nFirst:  %x\nSecond: %x", sum1, sum2)
+	}
+}
+
+// TestDeriveHmacDifferentKeys verifies that different private keys
+// produce different HMAC keys.
+func TestDeriveHmacDifferentKeys(t *testing.T) {
+	// Generate two different ECDSA private keys
+	privateKey1, err := crypto.GenerateKey()
+	if err != nil {
+		t.Fatalf("failed to generate first test private key: %v", err)
+	}
+
+	privateKey2, err := crypto.GenerateKey()
+	if err != nil {
+		t.Fatalf("failed to generate second test private key: %v", err)
+	}
+
+	hmac1 := deriveHmac(privateKey1)
+	hmac2 := deriveHmac(privateKey2)
+
+	testMessage := []byte("test message")
+	hmac1.Write(testMessage)
+	hmac2.Write(testMessage)
+
+	sum1 := hmac1.Sum(nil)
+	sum2 := hmac2.Sum(nil)
+
+	// Verify HMAC outputs are different for different private keys
+	if bytes.Equal(sum1, sum2) {
+		t.Errorf("HMAC outputs are identical for different private keys, expected them to differ")
+	}
+}
diff --git a/contracts b/contracts
index bdb8f8c68b2..c255a81e59f 160000
--- a/contracts
+++ b/contracts
@@ -1 +1 @@
-Subproject commit bdb8f8c68b2229fe9309fe9c03b37017abd1a2cd
+Subproject commit c255a81e59fdb6970c9745f0f41eee68bf2e35a0
diff --git a/contracts-legacy b/contracts-legacy
index 5f61a6b0e97..6c818041bd4 160000
--- a/contracts-legacy
+++ b/contracts-legacy
@@ -1 +1 @@
-Subproject commit 5f61a6b0e9799d7ccc0b3811f3893c68a14e43bf
+Subproject commit 6c818041bd48bc250890b39d6ab7a376fa9928a1
diff --git a/contracts-local/foundry.toml b/contracts-local/foundry.toml
index 82e46e97ef4..857fe3b9e51 100644
--- a/contracts-local/foundry.toml
+++ b/contracts-local/foundry.toml
@@ -57,6 +57,7 @@ libs = []
 cache_path  = 'forge-cache/gas-dimensions-yul'
 remappings = []
 auto_detect_remappings = false
+lint.lint_on_build = false
 
 [fmt]
 line_length = 100
diff --git a/daprovider/das/syncing_fallback_storage.go b/daprovider/das/syncing_fallback_storage.go
index 191e78e2c46..84e40575fa4 100644
--- a/daprovider/das/syncing_fallback_storage.go
+++ b/daprovider/das/syncing_fallback_storage.go
@@ -55,7 +55,7 @@ func init() {
 	}
 	BatchDeliveredID = sequencerInboxABI.Events[sequencerBatchDeliveredEvent].ID
 	sequencerBatchDataABI = sequencerInboxABI.Events[sequencerBatchDataEvent]
-	addSequencerL2BatchFromOriginCallABI = sequencerInboxABI.Methods["addSequencerL2BatchFromOrigin0"]
+	addSequencerL2BatchFromOriginCallABI = sequencerInboxABI.Methods["addSequencerL2BatchFromOrigin1"]
 }
 
 type SyncToStorageConfig struct {
diff --git a/deploy/deploy.go b/deploy/deploy.go
index e2038ad6bfb..3588d798a89 100644
--- a/deploy/deploy.go
+++ b/deploy/deploy.go
@@ -22,7 +22,7 @@ import (
 	"github.com/offchainlabs/nitro/util/headerreader"
 )
 
-func GenerateLegacyRollupConfig(prod bool, wasmModuleRoot common.Hash, rollupOwner common.Address, chainConfig *params.ChainConfig, serializedChainConfig []byte, loserStakeEscrow common.Address) rollup_legacy_gen.Config {
+func GenerateLegacyRollupConfig(prod bool, wasmModuleRoot common.Hash, rollupOwner common.Address, chainConfig *params.ChainConfig, serializedChainConfig []byte, loserStakeEscrow common.Address, espressoTEEVerifier common.Address) rollup_legacy_gen.Config {
 	var confirmPeriod uint64
 	if prod {
 		confirmPeriod = 45818
@@ -38,6 +38,7 @@ func GenerateLegacyRollupConfig(prod bool, wasmModuleRoot common.Hash, rollupOwn
 		Owner:                    rollupOwner,
 		LoserStakeEscrow:         loserStakeEscrow,
 		ChainId:                  chainConfig.ChainID,
+		EspressoTEEVerifier:      espressoTEEVerifier,
 		// TODO could the ChainConfig be just []byte?
 		ChainConfig: string(serializedChainConfig),
 		SequencerInboxMaxTimeVariation: rollup_legacy_gen.ISequencerInboxMaxTimeVariation{
diff --git a/espresso-tee-contracts b/espresso-tee-contracts
new file mode 160000
index 00000000000..bf6e60d862d
--- /dev/null
+++ b/espresso-tee-contracts
@@ -0,0 +1 @@
+Subproject commit bf6e60d862db8b3f1fccb2f8c10e737c8e4cef45
diff --git a/espresso/RELEASE_CHARTER.md b/espresso/RELEASE_CHARTER.md
new file mode 100644
index 00000000000..d2c87e84ff9
--- /dev/null
+++ b/espresso/RELEASE_CHARTER.md
@@ -0,0 +1,63 @@
+# Release Management Charter
+
+## Mission
+
+Deliver new code features systematically with clear documentation and validation before production release.
+
+## Release Types
+
+- **Pre-release**: New features ready for testing (on-going devnet testing)
+- **Release**: Production-ready features (see [Release Criteria Section](#5-release-criteria)).
+
+## Release Process
+
+### 1. Feature Development
+
+- [ ] Write design documentation on feature
+- [ ] Build the feature ensuring it works with the upstream branch
+- [ ] Add a feature enabling flag that allows to run the code without the feature being activated
+- [ ] Merge code relatively regularly to avoid diverging too much
+
+### 2. Pre-release Preparation
+
+- **Feature Description**
+  - [ ] Explain what the feature does in simple terms
+  - [ ] Document why we built it and what problem it solves (can link to existing)
+  - [ ] Maintain the changelogs.md file (`https://keepachangelog.com/en/1.1.0/`)
+
+- **Chain Network Setup**
+  - [ ] Update node configuration requirements (e.g., get hotshot block)
+  - [ ] List any new dependencies (e.g., DA providers)
+
+### 3. Pre-release Deployment
+
+- [ ] Create the GitHub release and check "Set as a pre-release"
+- [ ] Add a clear *warning* that this release is not production ready
+- [ ] Add documentation from previous section
+
+### 4. Pre-release Testing
+
+- [ ] Create image from tag and deploy to devnet environment
+- [ ] Enable Monitoring (e.g., alerts)
+- [ ] Enable Load Testing
+- [ ] Watch for stability issues and performance problems
+- [ ] Collect feedback and document encountered issues/limitations
+
+### 5. Release Criteria
+
+**Pre-release becomes Release when:**
+
+- [ ] Regression testing on new release went through successfully
+- [ ] Managed to produce high load on the devnet for:
+  - [ ] Tier 1 - 3 days successfully
+  - [ ] Tier 2 - 1 week successfully
+- [ ] Latest documentation updated
+  - [ ] Update release documentation if needed
+  - [ ] Describe tiered devnet testing results
+  - [ ] Include security assessment if we conducted an audit
+- [ ] Team agrees to making it production ready
+
+### 6. Archive Non-Qualifying Pre-releases
+
+- [ ] If pre-release does not meet release criteria, archive the release
+- [ ] Document reasons why promotion was not possible
diff --git a/espresso/RELEASE_TEMPLATE.MD b/espresso/RELEASE_TEMPLATE.MD
new file mode 100644
index 00000000000..ccc37a1be91
--- /dev/null
+++ b/espresso/RELEASE_TEMPLATE.MD
@@ -0,0 +1,53 @@
+# Release: [Version] - [Release Type: Pre-release | Release]
+
+## ⚠️ [Pre-release Only]
+
+**WARNING: This release is NOT production ready and is intended for devnet testing only.**
+
+## Description
+
+Brief overview of this release and its main purpose
+
+## Feature/Bug Fix (Select Applicable)
+
+- **Description**: [What it does]
+- **Problem Solved**: [Why we built it]
+- **Configuration**: [New settings/variables]
+- **Feature Flag**: [How to enable/disable]
+- **[Bug Fix]**: Issue description and resolution
+- **[Breaking Change]**: What changed (Change logs)
+
+## Requirements
+
+- Node configuration updates: [Details]
+- New dependencies: [List]
+- DA provider changes: [If applicable]
+- [ ] Run migration script (if applicable)
+
+## Testing & Validation
+
+### Pre-release
+
+- ✅ Devnet deployed and accessible
+- ✅ Monitoring and alerts configured
+- ⏳ Load testing scheduled/in progress
+- ⏳ Stability monitoring ongoing
+- ⚠️ Known limitations: [List]
+
+### Production Release
+
+- ✅ Devnet Tier 1 testing: [X days]
+- ✅ Devnet Tier 2 testing: [X days]
+- ✅ Security assessment: [Status]
+- ✅ Regression testing: [Status]
+- ⚠️ Known limitations: [List]
+
+## Rollback Plan
+
+[Steps to rollback if issues occur]
+
+## Documentation
+
+- Updated guides: [List]
+- Migration documentation: [Link]
+- Configuration examples: [Link]
diff --git a/espresso/attestation_verifier_client/attestation_verifier_client.go b/espresso/attestation_verifier_client/attestation_verifier_client.go
new file mode 100644
index 00000000000..c6ec07636e5
--- /dev/null
+++ b/espresso/attestation_verifier_client/attestation_verifier_client.go
@@ -0,0 +1,85 @@
+package attestationverifierclient
+
+import (
+	"bytes"
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/offchainlabs/nitro/arbutil"
+)
+
+type EspressoAttestationVerifierClient struct {
+	baseURL string
+}
+
+type OnchainProof struct {
+	Zktype      string `json:"zktype"`
+	ZkvmVersion string `json:"zkvm_version"`
+	ProgramID   struct {
+		VerifierID      string `json:"verifier_id"`
+		VerifierProofID string `json:"verifier_proof_id"`
+		AggregatorID    string `json:"aggregator_id"`
+	} `json:"program_id"`
+	RawProof struct {
+		EncodedProof string `json:"encoded_proof"`
+		Journal      string `json:"journal"`
+	} `json:"raw_proof"`
+	OnchainProof string `json:"onchain_proof"`
+	ProofType    string `json:"proof_type"`
+}
+
+func NewEspressoAttestationVerifierClient(
+	attestationServiceURL string,
+) *EspressoAttestationVerifierClient {
+	return &EspressoAttestationVerifierClient{
+		baseURL: strings.TrimSuffix(attestationServiceURL, "/"),
+	}
+}
+
+func (c *EspressoAttestationVerifierClient) GenerateZKProof(ctx context.Context, attestationBytes []byte) ([]byte, []byte, error) {
+	request, err := http.NewRequestWithContext(ctx, "POST", c.baseURL+"/generate_proof", bytes.NewBuffer(attestationBytes))
+	if err != nil {
+		return nil, nil, err
+	}
+	request.Header.Set("Content-Type", "application/octet-stream")
+
+	client := http.Client{
+		Timeout: 2 * time.Minute,
+	}
+	res, err := client.Do(request)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer res.Body.Close()
+
+	responseData, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if res.StatusCode != http.StatusOK {
+		return nil, nil, fmt.Errorf("attestation service returned status %d: %s", res.StatusCode, string(responseData))
+	}
+
+	var zkProof OnchainProof
+	err = json.Unmarshal(responseData, &zkProof)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	journalBytes, err := hex.DecodeString(arbutil.StripHexPrefix(zkProof.RawProof.Journal))
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to decode journal hex string: %w", err)
+	}
+	onchainProofBytes, err := hex.DecodeString(arbutil.StripHexPrefix(zkProof.OnchainProof))
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to decode onchain proof hex string: %w", err)
+	}
+	return journalBytes, onchainProofBytes, nil
+}
diff --git a/espresso/authdb/.gitignore b/espresso/authdb/.gitignore
new file mode 100644
index 00000000000..21f04089834
--- /dev/null
+++ b/espresso/authdb/.gitignore
@@ -0,0 +1,8 @@
+.DS_Store
+.idea
+*.log
+tmp/
+
+# tmp ancient store for test
+authdbancient
+testancient
diff --git a/espresso/authdb/DEV.md b/espresso/authdb/DEV.md
new file mode 100644
index 00000000000..aebd13b22aa
--- /dev/null
+++ b/espresso/authdb/DEV.md
@@ -0,0 +1,144 @@
+# Authenticated Storage (AuthDB) Architecture
+
+This document explains the authenticated storage mechanism designed to ensure data integrity for security-critical operations in the Espresso-Nitro integration.
+
+## Core Security Model
+
+**AuthDB** provides cryptographic integrity guarantees for all database operations using HMAC (Hash-based Message Authentication Code). Every stored value is protected by an authentication tag that prevents tampering and detects corruption.
+
+### Key Principle
+All security-critical data passes through AuthDB, which enforces that:
+1. **Write operations** automatically generate and store HMAC tags alongside data
+2. **Read operations** verify HMAC tags before returning data
+3. **Invalid/tampered data** causes read operations to fail with authentication errors
+
+## Architecture Overview
+
+```
+Application Layer
+        ↓
+    AuthDB (wrapper)
+        ↓
+  Underlying Database (Geth's ethdb)
+```
+
+### Core Components
+
+- **`AuthDB`** - Main wrapper implementing `ethdb.Database` interface
+- **`AuthBatch`** - Authenticated batch operations for atomic writes
+- **`AuthIterator`** - Iterator that skips internal tag entries and validates data
+- **`AuthAncientWriteOp`** - Handles freezer (ancient) data with authentication
+
+## Authentication Schemes
+
+### 1. Key-Value Store Authentication
+**Location:** `Put()`, `Get()`, `Has()` methods
+
+**Tag Generation:**
+```go
+tag = HMAC(key || value)
+```
+
+**Storage Pattern:**
+- Data: `key → value` 
+- Tag: `key-tag → HMAC(key || value)`
+
+**Critical Security Properties:**
+- Tags stored separately from data prevent value substitution attacks
+- Key inclusion in HMAC prevents key confusion attacks
+- Constant-time comparison (`hmac.Equal`) prevents timing attacks
+
+### 2. Ancient Store Authentication
+**Location:** `Ancient()`, `AncientRange()`, `ModifyAncients()` methods
+
+Ancient data uses two different authentication approaches based on data type:
+
+**Hash Table (Raw bytes):**
+```go
+stored_data = original_data || HMAC(kind || number || original_data)
+```
+
+**Structured Data (Headers/Bodies/Receipts):**
+```go
+auth_item = AncientItemWithTag{
+    item: original_item,
+    tag: HMAC(kind || number || RLP(original_item))
+}
+stored_data = RLP(auth_item)
+```
+
+## Security-Critical Functions
+
+### Enforcement Functions (`operations.go`)
+```go
+func enforceAuthenticatedWriter(db ethdb.KeyValueWriter) error
+func enforceAuthenticatedReader(db ethdb.KeyValueReader) error
+```
+
+**Purpose:** Compile-time + runtime guarantee that only `AuthDB`/`AuthBatch` instances are used for security-critical operations.
+
+**Audit Focus:** Verify all security-sensitive database operations in the codebase use these enforcement functions.
+
+### Domain-Specific Operations
+Functions like `WriteNextHotshotBlockNum`, `ReadInitAddresses` enforce authenticated storage for:
+- Hotshot consensus state tracking
+- Batcher address monitoring  
+- Event processing checkpoints
+
+**Audit Focus:** Confirm these operations cannot be bypassed with direct database access.
+
+## Attack Resistance
+
+### Tampering Detection
+- **Bit-flip attacks:** Any corruption in stored data fails HMAC verification
+- **Substitution attacks:** Cannot replace values due to key-specific tags
+- **Rollback attacks:** Sequence numbers in ancient data prevent replay
+
+### Authentication Bypasses
+- **Type confusion:** `enforceAuthenticated*` functions prevent use of raw database
+- **Tag forgery:** HMAC requires secret key unknown to attackers
+- **Timing attacks:** Constant-time comparison prevents tag extraction
+
+## Key Security Boundaries
+
+### 1. HMAC Key Management
+**Location:** `NewAuthDB(db ethdb.Database, mac hash.Hash)`
+
+**Security Requirement:** The `mac` parameter must be initialized with a cryptographically secure key. This key represents the root of trust for all authentication.
+
+**Audit Focus:** Verify HMAC key derivation and lifecycle management in calling code.
+
+### 2. Authentication Bypass Prevention
+**Critical Code Paths:**
+- All `Write*` and `Read*` functions in `operations.go` call enforcement functions
+- Iterator skips tag entries to prevent information disclosure
+- Batch operations maintain authentication invariants
+
+**Audit Focus:** Confirm no code paths exist that bypass AuthDB for security-critical data.
+
+### 3. Ancient Data Integrity
+**Critical Invariant:** Ancient data authentication handles both metadata (kind, number) and content in HMAC computation.
+
+**Audit Focus:** Verify freezer data cannot be modified without triggering authentication failures.
+
+## Testing Verification
+
+### Authentication Test Coverage
+- **`authdb_test.go`:** Full database suite compliance testing
+- **`operations_test.go`:** Security enforcement verification
+
+**Key Test:** `TestSecurityEnforcement` confirms raw database access fails with clear error messages.
+
+### Audit Recommendations
+1. **Static Analysis:** Verify no direct `ethdb.Database` usage for security-critical data
+2. **Integration Testing:** Confirm authentication failures halt system operation
+3. **Key Management Review:** Audit HMAC key generation and rotation procedures
+4. **Performance Impact:** Measure authentication overhead in production scenarios
+
+## Non-Security Operations
+
+Several database operations remain unauthenticated by design:
+- **Metadata operations:** `Ancients()`, `Tail()`, `AncientSize()` (not security-sensitive)
+- **Maintenance operations:** `Sync()`, `Compact()`, `Close()` (operational, not data integrity)
+
+**Rationale:** These operations don't affect data integrity and authentication would add unnecessary overhead.
\ No newline at end of file
diff --git a/espresso/authdb/README.md b/espresso/authdb/README.md
new file mode 100644
index 00000000000..a784d003824
--- /dev/null
+++ b/espresso/authdb/README.md
@@ -0,0 +1,241 @@
+# Authenticated Storage (AuthDB) Architecture
+
+This document explains the authenticated storage mechanism designed to ensure data integrity for security-critical operations in the Espresso-Nitro integration.
+
+## Core Security Model
+
+**AuthDB** provides cryptographic integrity guarantees for all database operations using HMAC (Hash-based Message Authentication Code). Every stored value is protected by an authentication tag that prevents tampering and detects corruption.
+
+### Key Principle
+All security-critical data passes through AuthDB, which enforces that:
+1. **Write operations** automatically generate and store HMAC tags alongside data
+2. **Read operations** verify HMAC tags before returning data
+3. **Invalid/tampered data** causes read operations to fail with authentication errors
+
+## Architecture Overview
+
+```
+Application Layer
+        ↓
+    AuthDB (wrapper)
+        ↓
+  Underlying Database (Geth's ethdb)
+```
+
+### Core Components
+
+- **`AuthDB`** - Main wrapper implementing `ethdb.Database` interface
+- **`AuthBatch`** - Authenticated batch operations for atomic writes
+- **`AuthIterator`** - Iterator that skips internal tag entries and validates data
+- **`AuthAncientWriteOp`** - Handles freezer (ancient) data with authentication
+
+## Operating Modes
+
+AuthDB supports three operational modes controlled via `isAuthReadsDisabled` parameter in `NewAuthDB()`:
+
+### 1. Full Authentication Mode (default)
+- **When**: `mac != nil` and `isAuthReadsDisabled = false`
+- **Behavior**: All reads and writes are authenticated with HMAC tags
+- **Use Case**: Production TEE environments with active integrity guarantees
+
+### 2. Write-Only Authentication Mode (bootstrap)
+- **When**: `mac != nil` and `isAuthReadsDisabled = true`
+- **Behavior**: Writes generate tags, reads skip verification
+- **Use Case**: TEE snapshot mode - node migrating from different enclave hash or non-TEE source
+- **Purpose**: Allows reading untrusted snapshot data while re-initializing authentication tags with new HMAC key
+
+### 3. No Authentication Mode
+- **When**: `mac = nil`
+- **Behavior**: No tags generated or verified
+- **Use Case**: Non-TEE environments (batch poster, testing) where authentication overhead is unnecessary
+
+## Snapshot and Bootstrap Flow
+
+The snapshot system enables secure state migration between TEE enclave hashes:
+
+### Snapshot Generation (`--node.espresso-caff-node.generate-snapshot`)
+1. Caff node runs normally with authentication enabled
+2. On shutdown, generates SHA-256 checksum of entire `l2chaindata` directory
+3. Stores checksum in `<datadir>/snapshot.txt`
+4. Snapshot includes all data but **excludes** lock files, logs, and manifests (see `arbutil.HashDir()`)
+
+### Snapshot Bootstrap (`--node.espresso-caff-node.snapshot-checksum <hash>`)
+1. Node verifies snapshot checksum against `l2chaindata` before opening database
+2. Deletes existing `auth-tags` ancient store (contains old HMAC tags from previous enclave)
+3. Opens database in **Write-Only Authentication Mode** (`isAuthReadsDisabled = true`)
+4. Calls `InitAuthTagsDatabase()` - iterates all key-value pairs, computes new HMAC tags with TEE's HMAC key
+5. Calls `InitAncientAuthTags()` - re-generates tags for all ancient chain data (headers, bodies, receipts, hashes)
+6. Node can now operate in Full Authentication Mode with new enclave's integrity guarantees
+
+**Security Property**: Bootstrap mode prevents chicken-and-egg problem - allows reading unverified data while establishing authentication layer with new key.
+
+## Authentication Schemes
+
+### 1. Key-Value Store Authentication
+**Location:** `Put()`, `Get()`, `Has()` methods
+
+**Tag Generation:**
+```go
+tag = HMAC(key || value)
+```
+
+**Storage Pattern:**
+- Data: `key → value` 
+- Tag: `key-tag → HMAC(key || value)`
+
+**Critical Security Properties:**
+- Tags stored separately from data prevent value substitution attacks
+- Key inclusion in HMAC prevents key confusion attacks
+- Constant-time comparison (`hmac.Equal`) prevents timing attacks
+
+### 2. Ancient Store Authentication
+**Location:** `Ancient()`, `AncientRange()`, `ModifyAncients()` methods
+
+Ancient data authentication uses a **separate tag freezer** to store HMAC tags independently from the main ancient store.
+
+**Directory Structure:**
+```
+<ancient_dir>/
+├── chain/          # Main chain freezer (unchanged format)
+│   ├── headers
+│   ├── bodies
+│   ├── receipts
+│   └── hashes
+└── auth-tags/      # Tag freezer (parallel structure)
+    ├── tag-headers  # HMAC tags for headers
+    ├── tag-bodies   # HMAC tags for bodies
+    ├── tag-receipts # HMAC tags for receipts
+    └── tag-hashes   # HMAC tags for hashes
+```
+
+**Tag Computation:**
+```go
+// For all ancient data types (raw and structured)
+tag = HMAC(kind || number || data)
+
+// For structured data (headers/bodies/receipts), data is RLP-encoded
+tag = HMAC(kind || number || RLP(item))
+```
+
+**Storage Pattern:**
+- **Main Data**: Stored unchanged in main chain freezer tables
+- **Tags**: Stored at same index in corresponding tag freezer tables
+
+**Atomicity:** Both main data and tags are written together via `ModifyAncients()`. If either write fails, the operation is aborted.
+
+**Modes:**
+- **Enabled**: Tag freezer created in `<ancient_dir>/auth-tags/` (requires valid ancient directory)
+- **Disabled**: No tags when `mac=nil` (authentication bypassed)
+
+## Security-Critical Functions
+
+### Enforcement Functions (`operations.go`)
+```go
+func enforceAuthenticatedWriter(db ethdb.KeyValueWriter) error
+func enforceAuthenticatedReader(db ethdb.KeyValueReader) error
+```
+
+**Purpose:** Compile-time + runtime guarantee that only `AuthDB`/`AuthBatch` instances are used for security-critical operations.
+
+**Audit Focus:** Verify all security-sensitive database operations in the codebase use these enforcement functions.
+
+### Domain-Specific Operations
+Functions like `WriteNextHotshotBlockNum`, `ReadInitAddresses` enforce authenticated storage for:
+- Hotshot consensus state tracking
+- Batcher address monitoring  
+- Event processing checkpoints
+
+**Audit Focus:** Confirm these operations cannot be bypassed with direct database access.
+
+## Attack Resistance
+
+### Tampering Detection
+- **Bit-flip attacks:** Any corruption in stored data fails HMAC verification
+- **Substitution attacks:** Cannot replace values due to key-specific tags
+- **Rollback attacks:** Sequence numbers in ancient data prevent replay
+
+### Authentication Bypasses
+- **Type confusion:** `enforceAuthenticated*` functions prevent use of raw database
+- **Tag forgery:** HMAC requires secret key unknown to attackers
+- **Timing attacks:** Constant-time comparison prevents tag extraction
+
+## Key Security Boundaries
+
+### 1. HMAC Key Management
+**Location:** `NewAuthDB(db ethdb.Database, mac hash.Hash)`
+
+**Security Requirement:** The `mac` parameter must be initialized with a cryptographically secure key. This key represents the root of trust for all authentication.
+
+**Initialization Requirement:** When `mac` is non-nil (authentication enabled), the database must provide a valid ancient directory via `AncientDatadir()`. If the ancient directory is missing or empty, `NewAuthDB` will return an error. This ensures tag persistence and prevents security degradation.
+
+**Audit Focus:** Verify HMAC key derivation and lifecycle management in calling code.
+
+### 2. Authentication Bypass Prevention
+**Critical Code Paths:**
+- All `Write*` and `Read*` functions in `operations.go` call enforcement functions
+- Iterator skips tag entries to prevent information disclosure
+- Batch operations maintain authentication invariants
+
+**Audit Focus:** Confirm no code paths exist that bypass AuthDB for security-critical data.
+
+### 3. Ancient Data Integrity
+**Critical Invariant:** Ancient data authentication handles both metadata (kind, number) and content in HMAC computation.
+
+**Audit Focus:** Verify freezer data cannot be modified without triggering authentication failures.
+
+## Testing Verification
+
+### Authentication Test Coverage
+- **`authdb_test.go`:** Full database suite compliance testing
+- **`operations_test.go`:** Security enforcement verification
+
+**Key Test:** `TestSecurityEnforcement` confirms raw database access fails with clear error messages.
+
+### Audit Recommendations
+1. **Static Analysis:** Verify no direct `ethdb.Database` usage for security-critical data
+2. **Integration Testing:** Confirm authentication failures halt system operation
+3. **Key Management Review:** Audit HMAC key generation and rotation procedures
+4. **Performance Impact:** Measure authentication overhead in production scenarios
+
+## Non-Security Operations
+
+Several database operations remain unauthenticated by design:
+- **Metadata operations:** `Ancients()`, `Tail()`, `AncientSize()` (not security-sensitive)
+- **Maintenance operations:** `Sync()`, `Compact()`, `Close()` (operational, not data integrity)
+
+**Rationale:** These operations don't affect data integrity and authentication would add unnecessary overhead.
+
+### WASM Database (Stylus Compilation Cache)
+
+**Authentication Status:** **SKIPPED** - WASM DB operations are not authenticated.
+
+**Location:** The WASM database stores pre-compiled native machine code for Stylus smart contracts, accessible via `WasmStore()` in the wrapped database.
+
+**Directory Structure:**
+```
+<datadir>/
+├── chaindata/     # Main authenticated chain database
+└── wasm/          # Unauthenticated WASM compilation cache
+```
+
+**Why WASM DB is Persisted:**
+
+Stylus programs (WebAssembly smart contracts) are compiled to native machine code (ARM64/AMD64) when first activated on-chain. This compilation is computationally expensive, so compiled artifacts are cached to disk:
+
+1. **Contract Activation** (`arbos/programs/native.go`): When a Stylus contract is deployed/activated, WASM bytecode is compiled to native machine code for all configured targets (WAVM, ARM64, AMD64)
+2. **StateDB Tracking** (`statedb_arbitrum.go`): Compiled artifacts are tracked in `StateDB.arbExtraData.activatedWasms` during transaction execution
+3. **Block Commit** (`statedb.go:1418-1428`): On block commit, activated WASMs are persisted to the WASM DB via `WriteActivation()` to avoid recompilation
+4. **Cache Lookup** (`native.go:236-291`): On subsequent executions, `getLocalAsm()` checks StateDB → WASM DB → recompile as fallback
+
+**Security Rationale for Skipping Authentication:**
+
+WASM DB corruption affects **performance only, not correctness**:
+
+- **Fraud Proof Generation:** WASM compilation is part of fraud proof verification, but tampering only impacts efficiency (forces recompilation). The fraud proof system validates execution results, not compilation artifacts.
+- **Block Processing:** If WASM DB is corrupted/tampered:
+  - Node detects mismatch between stored `moduleHash` and recompiled hash
+  - Falls back to on-the-fly recompilation from on-chain WASM bytecode
+  - Execution results remain deterministic and verifiable
+- **No State Transition Impact:** WASM DB never participates in consensus-critical state transitions. The canonical state is always derived from on-chain WASM bytecode in `StateDB`, not from the compilation cache.
+
+**Trade-off:** Authenticating WASM DB would add significant overhead for minimal security benefit, as the system self-heals through recompilation and hash verification.
diff --git a/espresso/authdb/ancient_test.go b/espresso/authdb/ancient_test.go
new file mode 100644
index 00000000000..2aaaa771378
--- /dev/null
+++ b/espresso/authdb/ancient_test.go
@@ -0,0 +1,235 @@
+package authdb
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/rawdb/ancienttest"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/ethdb/memorydb"
+
+	espresso_tee_utils "github.com/offchainlabs/nitro/cmd/util/espresso-tee-utils"
+)
+
+var whitelistedKinds = []string{
+	rawdb.ChainFreezerHashTable,
+	rawdb.ChainFreezerHeaderTable,
+	rawdb.ChainFreezerBodiesTable,
+	rawdb.ChainFreezerReceiptTable,
+}
+
+// testAuthDB wraps AuthDB to dynamically map arbitrary test kinds to whitelisted kinds.
+// This is necessary since ancienttest.TestAncientSuite will call with kind = "a", "b", etc.
+type testAuthDB struct {
+	*AuthDB // Embedded - inherits Ancients, Tail, Sync, TruncateHead, TruncateTail, Close, AncientDatadir
+	kindMap map[string]string
+}
+
+func newTestAuthDB(authdb *AuthDB) *testAuthDB {
+	t := &testAuthDB{
+		AuthDB:  authdb,
+		kindMap: make(map[string]string),
+	}
+	return t
+}
+
+// Returns the mapped kind for a test kind, adding it to the map if necessary
+func (t *testAuthDB) mapKind(testKind string) (string, bool) {
+	mapped, exists := t.kindMap[testKind]
+	if exists {
+		return mapped, true
+	} else {
+		if len(t.kindMap) >= len(whitelistedKinds) {
+			return "", false
+		}
+
+		t.kindMap[testKind] = whitelistedKinds[len(t.kindMap)]
+		return t.kindMap[testKind], true
+	}
+}
+
+func (t *testAuthDB) HasAncient(kind string, number uint64) (bool, error) {
+	mapped, ok := t.mapKind(kind)
+	if !ok {
+		return false, nil
+	}
+	_, err := t.AuthDB.Ancient(mapped, number)
+	return err == nil, nil
+}
+
+func (t *testAuthDB) Ancient(kind string, number uint64) ([]byte, error) {
+	mapped, ok := t.mapKind(kind)
+	if !ok {
+		return nil, fmt.Errorf("unknown table %s", kind)
+	}
+	return t.AuthDB.Ancient(mapped, number)
+}
+
+func (t *testAuthDB) AncientRange(kind string, start, count, maxBytes uint64) ([][]byte, error) {
+	mapped, ok := t.mapKind(kind)
+	if !ok {
+		return nil, fmt.Errorf("unknown table %s", kind)
+	}
+	return t.AuthDB.AncientRange(mapped, start, count, maxBytes)
+}
+
+func (t *testAuthDB) AncientSize(kind string) (uint64, error) {
+	mapped, ok := t.mapKind(kind)
+	if !ok {
+		return 0, fmt.Errorf("unknown table %s", kind)
+	}
+	return t.AuthDB.AncientSize(mapped)
+}
+
+func (t *testAuthDB) ReadAncients(fn func(ethdb.AncientReaderOp) error) error {
+	return t.AuthDB.ReadAncients(func(op ethdb.AncientReaderOp) error {
+		return fn(&testAncientReaderOp{AncientReaderOp: op, testdb: t})
+	})
+}
+
+func (t *testAuthDB) ModifyAncients(fn func(ethdb.AncientWriteOp) error) (int64, error) {
+	return t.AuthDB.ModifyAncients(func(op ethdb.AncientWriteOp) error {
+		return fn(&testAncientWriteOp{AncientWriteOp: op, testdb: t})
+	})
+}
+
+type testAncientReaderOp struct {
+	ethdb.AncientReaderOp // Embedded - inherits Ancients, Tail
+	testdb                *testAuthDB
+}
+
+func (op *testAncientReaderOp) HasAncient(kind string, number uint64) (bool, error) {
+	mapped, ok := op.testdb.mapKind(kind)
+	if !ok {
+		return false, nil
+	}
+	_, err := op.AncientReaderOp.Ancient(mapped, number)
+	return err == nil, nil
+}
+
+func (op *testAncientReaderOp) Ancient(kind string, number uint64) ([]byte, error) {
+	mapped, ok := op.testdb.mapKind(kind)
+	if !ok {
+		return nil, fmt.Errorf("unknown table %s", kind)
+	}
+	return op.AncientReaderOp.Ancient(mapped, number)
+}
+
+func (op *testAncientReaderOp) AncientRange(kind string, start, count, maxBytes uint64) ([][]byte, error) {
+	mapped, ok := op.testdb.mapKind(kind)
+	if !ok {
+		return nil, fmt.Errorf("unknown table %s", kind)
+	}
+	return op.AncientReaderOp.AncientRange(mapped, start, count, maxBytes)
+}
+
+func (op *testAncientReaderOp) AncientSize(kind string) (uint64, error) {
+	mapped, ok := op.testdb.mapKind(kind)
+	if !ok {
+		return 0, fmt.Errorf("unknown table %s", kind)
+	}
+	return op.AncientReaderOp.AncientSize(mapped)
+}
+
+type testAncientWriteOp struct {
+	ethdb.AncientWriteOp // Embedded - no pure pass-through methods, but cleaner interface
+	testdb               *testAuthDB
+}
+
+func (op *testAncientWriteOp) Append(kind string, number uint64, item interface{}) error {
+	mapped, ok := op.testdb.mapKind(kind)
+	if !ok {
+		return fmt.Errorf("unknown table %s", kind)
+	}
+	return op.AncientWriteOp.Append(mapped, number, item)
+}
+
+func (op *testAncientWriteOp) AppendRaw(kind string, number uint64, item []byte) error {
+	mapped, ok := op.testdb.mapKind(kind)
+	if !ok {
+		return fmt.Errorf("unknown table %s", kind)
+	}
+	return op.AncientWriteOp.AppendRaw(mapped, number, item)
+}
+
+// testDatabase wraps KeyValueStore and Freezer for test purposes
+type testDatabase struct {
+	ethdb.KeyValueStore
+	*rawdb.Freezer
+}
+
+func (db *testDatabase) Close() error {
+	if err := db.Freezer.Close(); err != nil {
+		return err
+	}
+	return db.KeyValueStore.Close()
+}
+
+func (db *testDatabase) Compact(start []byte, limit []byte) error { return nil }
+func (db *testDatabase) Stat() (string, error)                    { return "", nil }
+func (db *testDatabase) WasmDataBase() ethdb.KeyValueStore        { return db.KeyValueStore }
+
+// TestAuthDBAncientSuite runs geth's comprehensive ancient store test suite
+// against AuthDB. This validates that all ancient store operations work correctly
+// with authentication wrapping.
+func TestAuthDBAncientSuite(t *testing.T) {
+	ancienttest.TestAncientSuite(t, func(kinds []string) ethdb.AncientStore {
+		if len(kinds) > len(whitelistedKinds) {
+			t.Fatalf("only support max %d kinds", len(whitelistedKinds))
+		}
+
+		// Create only the tables we need for the test kinds
+		tables := make(map[string]bool)
+		for i := range len(kinds) {
+			tables[whitelistedKinds[i]] = true
+		}
+		tableWithConfigs := rawdb.NewEspressoTableConfig(tables)
+
+		freezerDir := t.TempDir()
+		freezer, err := rawdb.NewFreezer(freezerDir, "", false, 2049, tableWithConfigs)
+		Require(t, err)
+		db := &testDatabase{KeyValueStore: memorydb.New(), Freezer: freezer}
+
+		mac, err := espresso_tee_utils.HmacForTest()
+		Require(t, err)
+		// Create AuthDB with only the tag tables we need
+		// NOTE: our NewAuthDB will default to a tagFreezer with all 4 tables whose internal sync
+		// logic will ensure all tables have the same length. For our test, we only use <=4 tables
+		// thus we use an internal constructor with specified freezer table
+		// Convert main table names to tag table names
+		tagTables := make(map[string]bool)
+		for mainTable := range tables {
+			if tagTable, ok := getTagTable(mainTable); ok {
+				tagTables[tagTable] = true // No snappy compression for tags
+			}
+		}
+		authDB, err := newAuthDBWithFreezerTables(db, mac, tagTables, false)
+		Require(t, err)
+
+		return newTestAuthDB(&authDB)
+	})
+}
+
+// TestAuthDBAncientSuiteNoAuth runs the test suite without authentication enabled.
+// This validates that AuthDB correctly passes through to the underlying store
+// when mac is nil.
+func TestAuthDBAncientSuiteNoAuth(t *testing.T) {
+	ancienttest.TestAncientSuite(t, func(kinds []string) ethdb.AncientStore {
+		tables := make(map[string]bool)
+		for _, kind := range kinds {
+			tables[kind] = true
+		}
+
+		tableWithConfigs := rawdb.NewEspressoTableConfig(tables)
+
+		freezerDir := t.TempDir()
+		freezer, err := rawdb.NewFreezer(freezerDir, "", false, 2049, tableWithConfigs)
+		Require(t, err)
+		db := &testDatabase{KeyValueStore: memorydb.New(), Freezer: freezer}
+
+		authDB, err := NewAuthDB(db, nil, false)
+		Require(t, err)
+		return &authDB
+	})
+}
diff --git a/espresso/authdb/authdb.go b/espresso/authdb/authdb.go
new file mode 100644
index 00000000000..540d2a356e9
--- /dev/null
+++ b/espresso/authdb/authdb.go
@@ -0,0 +1,759 @@
+package authdb
+
+import (
+	"bytes"
+	"crypto/hmac"
+	"errors"
+	"fmt"
+	"hash"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+var (
+	// ErrAuthTagMissing is returned when a tag cannot be found in the tag store
+	ErrAuthTagMissing = errors.New("authentication tag missing")
+	// ErrAuthTagMismatch is returned when a tag doesn't match the computed value
+	ErrAuthTagMismatch = errors.New("authentication tag mismatch")
+	// ErrNoAncients is returned when no ancients data is stored in the database
+	ErrNoAncients = errors.New("no ancients data is stored in the database")
+)
+
+type AuthDB struct {
+	ethdb.Database           // Embedded - inherits methods not needing authentication
+	mac            hash.Hash // HMAC func or nil to disable authentication
+
+	// Tag freezer stores authentication tags in separate ancient store
+	tagFreezer *rawdb.Freezer
+
+	// isAuthReadsDisabled is a flag to disable auth reads
+	// Its used during initial bootstrapping to avoid reading auth tags so that we can
+	// add new tags using the new tmac key from a different enclave code
+	isAuthReadsDisabled bool
+}
+
+func NewAuthDB(db ethdb.Database, mac hash.Hash, isAuthReadsDisabled bool) (AuthDB, error) {
+	return newAuthDBWithFreezerTables(db, mac, authTagTableNoSnappy, isAuthReadsDisabled)
+}
+
+func newAuthDBWithFreezerTables(db ethdb.Database, mac hash.Hash, tagTables map[string]bool, isAuthReadsDisabled bool) (AuthDB, error) {
+	if db == nil {
+		return AuthDB{}, errors.New("db is nil during authdb creation")
+	}
+
+	authDB := AuthDB{
+		Database:            db,
+		mac:                 mac,
+		isAuthReadsDisabled: isAuthReadsDisabled,
+	}
+
+	if mac == nil {
+		log.Warn("new AuthDB with authentication disabled")
+		return authDB, nil
+	}
+
+	// Determine ancient directory
+	ancientDir, err := db.AncientDatadir()
+	if err != nil || ancientDir == "" {
+		log.Warn("no/empty ancient datadir: skip authenticating ancient store")
+		return authDB, nil //nolint:nilerr
+	}
+
+	// Initialize tag freezer
+	// Note: We don't know if the DB is read-only from this interface
+	// The freezer will handle file locks appropriately
+	tagFreezer, err := newAuthTagFreezerWithTables(ancientDir, false, tagTables)
+	if err != nil {
+		return authDB, fmt.Errorf("failed to initialize tag freezer: %w", err)
+	}
+	authDB.tagFreezer = tagFreezer
+
+	log.Info("AuthDB initialized with tag freezer", "ancient_dir", ancientDir)
+	return authDB, nil
+}
+
+// computeMac computes HMAC for key-value pair
+func (d *AuthDB) computeMac(key []byte, val []byte) []byte {
+	d.mac.Reset()
+	d.mac.Write(key)
+	d.mac.Write(val)
+	return d.mac.Sum(nil)
+}
+
+func (d *AuthDB) Ancient(kind string, number uint64) ([]byte, error) {
+	data, err := d.Database.Ancient(kind, number)
+	if err != nil {
+		return nil, err
+	}
+
+	if d.mac == nil {
+		return data, nil
+	}
+
+	if err = d.verifyAncientTag(kind, number, data); err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+// computeMacForAncient computes HMAC for kind, number, and data
+func (d *AuthDB) computeMacForAncient(kind string, number uint64, data []byte) []byte {
+	d.mac.Reset()
+	d.mac.Write([]byte(kind))
+	d.mac.Write(EncodeUint64(number))
+	d.mac.Write(data)
+	return d.mac.Sum(nil)
+}
+
+func (d *AuthDB) verify(key []byte, val []byte) error {
+	if d.isAuthReadsDisabled {
+		// We return true because we don't want to fail the read operation
+		return nil
+	}
+
+	expectedTag, err := d.Database.Get(genericAuthTagKey(key))
+	if err != nil {
+		return fmt.Errorf("failed to get auth tag key:%b, err:%w", key, err)
+	}
+
+	tag := d.computeMac(key, val)
+
+	if !hmac.Equal(expectedTag, tag) {
+		return fmt.Errorf("%w: key=%v val=%d", ErrAuthTagMismatch, key, val)
+	}
+	return nil
+}
+
+// verifyAncientTag reads the tag from the tag store and verifies it matches the data
+func (d *AuthDB) verifyAncientTag(kind string, number uint64, data []byte) error {
+	if d.isAuthReadsDisabled {
+		// We return true because we don't want to fail the read operation
+		return nil
+	}
+	// Get the corresponding tag table name
+	tagTable, ok := getTagTable(kind)
+	if !ok {
+		return fmt.Errorf("%w: unknown table kind: %s", errors.ErrUnsupported, kind)
+	}
+
+	// Retrieve stored tag from tag freezer
+	if d.tagFreezer == nil {
+		return errors.New("tag freezer not initialized")
+	}
+
+	storedTag, err := d.tagFreezer.Ancient(tagTable, number)
+	if err != nil {
+		return fmt.Errorf("%w: %w", ErrAuthTagMissing, err)
+	}
+
+	// Compute expected tag
+	expectedTag := d.computeMacForAncient(kind, number, data)
+
+	// Verify tag
+	if !hmac.Equal(expectedTag, storedTag) {
+		return fmt.Errorf("%w: kind=%s number=%d", ErrAuthTagMismatch, kind, number)
+	}
+
+	return nil
+}
+
+func (d *AuthDB) AncientRange(kind string, start, count, maxBytes uint64) ([][]byte, error) {
+	items, err := d.Database.AncientRange(kind, start, count, maxBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	if d.mac == nil {
+		return items, nil
+	}
+
+	for i, data := range items {
+		// #nosec G115 -- i is guaranteed non-negative
+		err := d.verifyAncientTag(kind, start+uint64(i), data)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return items, nil
+}
+
+// Ancients, Tail, AncientSize inherited from embedded Database - unauthenticated but not security-sensitive
+
+func (d *AuthDB) ReadAncients(fn func(ethdb.AncientReaderOp) error) error {
+	return d.Database.ReadAncients(func(op ethdb.AncientReaderOp) error {
+		return fn(&AuthAncientReaderOp{AuthDB: d})
+	})
+}
+
+// AuthAncientReaderOp wraps AncientReaderOp to provide authenticated reads
+// Embedding authDB provides all methods automatically
+type AuthAncientReaderOp struct {
+	*AuthDB // Embedded - all ancient read methods delegated
+}
+
+// AuthAncientWriteOp wraps AncientWriteOp to write data and tags separately
+type AuthAncientWriteOp struct {
+	inner    ethdb.AncientWriteOp
+	authDB   *AuthDB
+	tagBatch []tagWrite // Collect tag writes to apply after main writes
+}
+
+type tagWrite struct {
+	kind   string
+	number uint64
+	tag    []byte
+}
+
+// Append writes structured data to main store and computes tag
+func (op *AuthAncientWriteOp) Append(kind string, number uint64, item interface{}) error {
+	// Write original data unchanged to main store
+	if err := op.inner.Append(kind, number, item); err != nil {
+		return err
+	}
+
+	// If authentication disabled, we're done
+	if op.authDB.mac == nil {
+		return nil
+	}
+
+	// Compute tag over RLP-encoded item
+	var buf bytes.Buffer
+	if err := rlp.Encode(&buf, item); err != nil {
+		return fmt.Errorf("failed to RLP encode for tag: %w", err)
+	}
+
+	tag := op.authDB.computeMacForAncient(kind, number, buf.Bytes())
+
+	// Store tag write for later
+	op.tagBatch = append(op.tagBatch, tagWrite{
+		kind:   kind,
+		number: number,
+		tag:    tag,
+	})
+
+	return nil
+}
+
+// AppendRaw writes raw data to main store and computes tag
+func (op *AuthAncientWriteOp) AppendRaw(kind string, number uint64, item []byte) error {
+	// Write original data unchanged to main store
+	if err := op.inner.AppendRaw(kind, number, item); err != nil {
+		return err
+	}
+
+	// If authentication disabled, we're done
+	if op.authDB.mac == nil {
+		return nil
+	}
+
+	// Compute tag over raw bytes
+	tag := op.authDB.computeMacForAncient(kind, number, item)
+
+	// Store tag write for later
+	op.tagBatch = append(op.tagBatch, tagWrite{
+		kind:   kind,
+		number: number,
+		tag:    tag,
+	})
+	return nil
+}
+
+// writeTags writes all collected tags to the tag store
+func (op *AuthAncientWriteOp) writeTags() error {
+	if op.authDB.mac == nil || len(op.tagBatch) == 0 {
+		return nil
+	}
+
+	if op.authDB.tagFreezer == nil {
+		return errors.New("tag freezer not initialized")
+	}
+
+	// Write to tag freezer
+	_, err := op.authDB.tagFreezer.ModifyAncients(func(tagOp ethdb.AncientWriteOp) error {
+		for _, tw := range op.tagBatch {
+			tagTable, ok := getTagTable(tw.kind)
+			if !ok {
+				continue // Skip unsupported tables
+			}
+			if err := tagOp.AppendRaw(tagTable, tw.number, tw.tag); err != nil {
+				return fmt.Errorf("failed to write tag for %s#%d: %w", tw.kind, tw.number, err)
+			}
+		}
+		return nil
+	})
+	return err
+}
+
+func (d *AuthDB) ModifyAncients(fn func(ethdb.AncientWriteOp) error) (int64, error) {
+	if d.mac == nil {
+		return d.Database.ModifyAncients(fn)
+	}
+
+	// Create our wrapper that collects tag writes
+	var authOp *AuthAncientWriteOp
+
+	// Execute main writes
+	writeSize, err := d.Database.ModifyAncients(func(op ethdb.AncientWriteOp) error {
+		authOp = &AuthAncientWriteOp{
+			inner:    op,
+			authDB:   d,
+			tagBatch: make([]tagWrite, 0),
+		}
+		return fn(authOp)
+	})
+
+	// Main write failed - don't write tags
+	if err != nil {
+		return writeSize, err
+	}
+
+	// Main writes succeeded - now write tags
+	if authOp != nil {
+		if tagErr := authOp.writeTags(); tagErr != nil {
+			// Future reads will fail verification
+			log.Crit("Failed to write authentication tags after successful main write",
+				"error", tagErr, "writes", len(authOp.tagBatch))
+			return writeSize, fmt.Errorf("tag write failed: %w", tagErr)
+		}
+	}
+
+	return writeSize, nil
+}
+
+func (d *AuthDB) TruncateHead(n uint64) (uint64, error) {
+	// Truncate main database first
+	old, err := d.Database.TruncateHead(n)
+	if err != nil {
+		return old, fmt.Errorf("failed to truncate main database head: %w", err)
+	}
+
+	// No tag freezer or auth disabled - nothing to sync
+	if d.mac == nil || d.tagFreezer == nil {
+		return old, nil
+	}
+
+	// Get current tag count
+	items, err := d.tagFreezer.Ancients()
+	if err != nil {
+		log.Crit("Failed to get tag freezer ancients count after main truncation",
+			"n", n, "error", err)
+		return old, fmt.Errorf("failed to get tag freezer ancients count: %w", err)
+	}
+
+	// Check for missing tags - database already corrupt
+	if items < n {
+		log.Crit("Tag freezer has fewer items than main database after truncation",
+			"tag_items", items, "data_items", n, "old", old)
+		return old, fmt.Errorf("tag count mismatch: have %d tags but %d data items", items, n)
+	}
+
+	// Already in sync
+	if items == n {
+		return old, nil
+	}
+
+	// Truncate excess tags
+	_, err = d.tagFreezer.TruncateHead(n)
+	if err != nil {
+		log.Crit("Failed to truncate tag freezer head after main truncation succeeded",
+			"n", n, "old", old, "error", err)
+		return old, fmt.Errorf("tag freezer truncate failed after main truncate: %w", err)
+	}
+	return old, nil
+}
+
+func (d *AuthDB) TruncateTail(n uint64) (uint64, error) {
+	// Truncate main database first
+	old, err := d.Database.TruncateTail(n)
+	if err != nil {
+		return old, fmt.Errorf("failed to truncate main database tail: %w", err)
+	}
+
+	// No tag freezer or auth disabled - nothing to sync
+	if d.mac == nil || d.tagFreezer == nil {
+		return old, nil
+	}
+
+	// Get current tag state
+	items, err := d.tagFreezer.Ancients()
+	if err != nil {
+		log.Crit("Failed to get tag freezer ancients count after main truncation",
+			"n", n, "error", err)
+		return old, fmt.Errorf("failed to get tag freezer ancients count: %w", err)
+	}
+
+	tail, err := d.tagFreezer.Tail()
+	if err != nil {
+		log.Crit("Failed to get tag freezer tail after main truncation",
+			"n", n, "error", err)
+		return old, fmt.Errorf("failed to get tag freezer tail: %w", err)
+	}
+
+	// Tag tail ahead of requested position - database corrupt
+	if tail > n {
+		log.Crit("Tag freezer tail is ahead of main database after TruncateTail",
+			"tag_tail", tail, "requested_n", n, "old", old)
+		return old, fmt.Errorf("tag tail mismatch: tag_tail=%d > n=%d", tail, n)
+	}
+
+	// Already in sync
+	if tail == n {
+		return old, nil
+	}
+
+	// Truncate tail to match main database
+	if items > 0 {
+		_, err = d.tagFreezer.TruncateTail(n)
+		if err != nil {
+			log.Crit("Failed to truncate tag freezer tail after main truncation succeeded",
+				"n", n, "old", old, "error", err)
+			return old, fmt.Errorf("tag freezer truncate failed after main truncate: %w", err)
+		}
+	}
+	return old, nil
+}
+
+func (d *AuthDB) Sync() error {
+	err := d.Database.SyncAncient()
+	if err != nil {
+		return err
+	}
+
+	// Sync tag freezer
+	if d.tagFreezer != nil {
+		if tagErr := d.tagFreezer.SyncAncient(); tagErr != nil {
+			return fmt.Errorf("failed to sync tag freezer: %w", tagErr)
+		}
+	}
+
+	return nil
+}
+
+// AncientDatadir, Stat inherited from embedded Database
+
+func (d *AuthDB) Close() error {
+	var errs []error
+
+	// Close tag freezer first
+	if d.tagFreezer != nil {
+		if err := d.tagFreezer.Close(); err != nil {
+			log.Error("Failed to close tag freezer", "err", err)
+			errs = append(errs, fmt.Errorf("tag freezer close: %w", err))
+		}
+	}
+
+	// Close main DB
+	if err := d.Database.Close(); err != nil {
+		errs = append(errs, fmt.Errorf("main db close: %w", err))
+	}
+
+	if len(errs) > 0 {
+		return fmt.Errorf("close errors: %v", errs)
+	}
+	return nil
+}
+
+// Compact, Delete, DeleteRange inherited from embedded ethdb.Database
+
+func (d *AuthDB) NewBatch() ethdb.Batch {
+	inner := d.Database.NewBatch()
+	return &AuthBatch{Batch: inner, authDB: d}
+}
+
+func (d *AuthDB) NewBatchWithSize(size int) ethdb.Batch {
+	inner := d.Database.NewBatchWithSize(size)
+	return &AuthBatch{Batch: inner, authDB: d}
+}
+
+// WasmDataBase, WasmTargets inherited from embedded Database - pass through for in-memory fraud game simulation
+
+func (d *AuthDB) Put(key []byte, value []byte) error {
+	// Always store the actual data first
+	err := d.Database.Put(key, value)
+	if err != nil {
+		return err
+	}
+
+	if d.mac == nil {
+		return nil
+	}
+
+	// add auth tags to every entry
+	d.mac.Reset()
+	d.mac.Write(key)
+	d.mac.Write(value)
+	tag := d.mac.Sum(nil)
+
+	err = d.Database.Put(genericAuthTagKey(key), tag)
+	if err != nil {
+		log.Crit("failed to write auth tag", "dbkey", key, "err", err)
+		return err
+	}
+	return nil
+}
+
+func (d *AuthDB) Has(key []byte) (bool, error) {
+	_, err := d.Get(key)
+	if err != nil {
+		if rawdb.IsDbErrNotFound(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("failed to Get during Has: %w", err)
+	}
+
+	return true, nil
+}
+
+func (d *AuthDB) Get(key []byte) ([]byte, error) {
+	val, err := d.Database.Get(key)
+	if err != nil {
+		return nil, err
+	}
+
+	if d.mac == nil {
+		return val, nil
+	}
+
+	if err := d.verify(key, val); err != nil {
+		return nil, fmt.Errorf("failed to authenticate: key=%v val=%d err=%w", key, val, err)
+	}
+
+	return val, nil
+}
+
+func (d *AuthDB) NewIterator(prefix []byte, start []byte) ethdb.Iterator {
+	inner := d.Database.NewIterator(prefix, start)
+	it := NewAuthIterator(inner, d)
+	return &it
+}
+
+type AuthIterator struct {
+	ethdb.Iterator // Embedded - inherits Error, Key, Release
+	db             *AuthDB
+}
+
+func NewAuthIterator(inner ethdb.Iterator, db *AuthDB) AuthIterator {
+	return AuthIterator{Iterator: inner, db: db}
+}
+
+func (it *AuthIterator) Next() bool {
+	for it.Iterator.Next() {
+		// Skip auth tag keys that end with "-tag"
+		key := it.Iterator.Key()
+		if !bytes.HasSuffix(key, genericAuthTagSuffix) {
+			return true
+		}
+	}
+	return false
+}
+
+func (it *AuthIterator) Value() []byte {
+	key := it.Key()
+	val := it.Iterator.Value()
+	if it.db.mac == nil {
+		return val
+	}
+
+	if err := it.db.verify(key, val); err != nil {
+		log.Error("failed to authenticate", "key", key, "val", val, "err", err)
+		return nil
+	}
+	return val
+}
+
+// AuthBatch wraps ethdb.Batch to provide authenticated batch operations
+type AuthBatch struct {
+	ethdb.Batch // Embedded - inherits Delete, ValueSize, Write, Reset, Replay
+	authDB      *AuthDB
+}
+
+// Put adds a key-value pair to the batch
+func (b *AuthBatch) Put(key []byte, value []byte) error {
+	if err := b.Batch.Put(key, value); err != nil {
+		return err
+	}
+
+	if b.authDB.mac != nil {
+		tag := b.authDB.computeMac(key, value)
+
+		if err := b.Batch.Put(genericAuthTagKey(key), tag); err != nil {
+			return fmt.Errorf("failed to put auth tag for key %s: %w", key, err)
+		}
+
+	}
+	return nil
+}
+
+// Get retrieves a value from the batch with authentication
+func (b *AuthBatch) Get(key []byte) ([]byte, error) {
+	val, err := b.authDB.Database.Get(key)
+	if err != nil {
+		return nil, err
+	}
+	if b.authDB.mac == nil {
+		return val, nil
+	}
+
+	if err := b.authDB.verify(key, val); err != nil {
+		return nil, fmt.Errorf("failed to authenticate: key=%v val=%d err=%w", key, val, err)
+	}
+	return val, nil
+}
+
+// InitAuthTags initializes auth tags for all keys in the database
+// when the node is started in the snapshot mode (which means when its initially provided a snapshot from another TEE code hash/non-tee node)
+func (d *AuthDB) InitAuthTagsDatabase(batchSize int) error {
+	var (
+		prefix     []byte
+		start      []byte
+		startTime  = time.Now()
+		loggedTime = time.Now()
+		count      = 0
+	)
+	log.Info("Starting adding auth tags to the database")
+
+	// Use the raw database iterator to avoid per-key auth verification during initialization
+	it := d.Database.NewIterator(prefix, start)
+	defer it.Release()
+
+	// Buffer writes in a raw batch to reduce I/O and avoid writing tags-for-tags
+	batch := d.Database.NewBatch()
+
+	// For each key value pair in the database add an auth tag
+	for it.Next() {
+		key := it.Key()
+		// Skip keys that are themselves tag entries
+		if bytes.HasSuffix(key, genericAuthTagSuffix) {
+			continue
+		}
+		value := it.Value()
+
+		// Compute and write the tag in the raw batch
+		tag := d.computeMac(key, value)
+		if err := batch.Put(genericAuthTagKey(key), tag); err != nil {
+			batch.Reset()
+			return fmt.Errorf("failed to put auth tag for key %v: %w", key, err)
+		}
+		count++
+
+		// Periodically flush to avoid huge batches and reduce fsync overhead
+		if count%batchSize == 0 {
+			if err := batch.Write(); err != nil {
+				batch.Reset()
+				return fmt.Errorf("failed to write auth tag batch: %w", err)
+			}
+			batch.Reset()
+		}
+		// if 5 minuetes have passed still log
+		if time.Since(loggedTime) > 5*time.Minute {
+			log.Info("Progress adding auth tags", "count", count, "elapsed", common.PrettyDuration(time.Since(startTime)))
+			loggedTime = time.Now()
+		}
+	}
+
+	// Flush any remaining buffered tags
+	if err := batch.Write(); err != nil {
+		batch.Reset()
+		return fmt.Errorf("failed to write final auth tag batch: %w", err)
+	}
+	log.Info("Successfully added auth tags to the database")
+	return nil
+}
+
+// InitAncientAuthTags initializes auth tags for all ancients in the database
+// when the node is started in the snapshot mode (which means when its initially provided a snapshot from another TEE code hash/non-tee node)
+func (d *AuthDB) InitAncientAuthTags(batchSize uint64) error {
+	if batchSize == 0 {
+		return fmt.Errorf("batchSize must be greater than 0")
+	}
+	firstBlock, err := d.Database.Tail()
+	if err != nil {
+		return err
+	}
+	numAncients, err := d.Database.Ancients()
+	if err != nil {
+		return err
+	}
+
+	if numAncients == 0 {
+		return nil
+	}
+
+	log.Info("Starting adding ancient auth tags")
+
+	for offset := uint64(0); offset < numAncients; offset += batchSize {
+		count := batchSize
+
+		if offset+batchSize > numAncients {
+			count = numAncients - offset
+		}
+
+		currentBlock := firstBlock + offset
+
+		hashData, blockBodyData, receiptData, headerData, err := d.readChainAncients(currentBlock, count)
+		if err != nil {
+			return err
+		}
+
+		_, err = d.tagFreezer.ModifyAncients(func(tagOp ethdb.AncientWriteOp) error {
+			for i := uint64(0); i < count; i++ {
+				num := currentBlock + uint64(i)
+
+				if err := tagOp.AppendRaw(AuthTagHashTable, num, hashData[i]); err != nil {
+					return err
+				}
+				if err := tagOp.AppendRaw(AuthTagHeaderTable, num, headerData[i]); err != nil {
+					return err
+				}
+				if err := tagOp.AppendRaw(AuthTagBodiesTable, num, blockBodyData[i]); err != nil {
+					return err
+				}
+				if err := tagOp.AppendRaw(AuthTagReceiptTable, num, receiptData[i]); err != nil {
+					return err
+				}
+			}
+			return nil
+		})
+
+		if err != nil {
+			return err
+		}
+
+		log.Info("Processed batch", "from", currentBlock, "count", count, "num_ancients", numAncients)
+	}
+
+	log.Info("Successfully added auth tags to ancients",
+		"from", firstBlock, "count", numAncients)
+	return nil
+}
+
+func (d *AuthDB) readChainAncients(firstBlock, numAncients uint64) (hashData, bodyData, receiptData, headerData [][]byte, err error) {
+
+	hashData, err = d.Database.AncientRange(rawdb.ChainFreezerHashTable, firstBlock, numAncients, 0)
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+
+	bodyData, err = d.Database.AncientRange(rawdb.ChainFreezerBodiesTable, firstBlock, numAncients, 0)
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+
+	receiptData, err = d.Database.AncientRange(rawdb.ChainFreezerReceiptTable, firstBlock, numAncients, 0)
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+
+	headerData, err = d.Database.AncientRange(rawdb.ChainFreezerHeaderTable, firstBlock, numAncients, 0)
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+
+	return hashData, bodyData, receiptData, headerData, nil
+}
diff --git a/espresso/authdb/authdb_test.go b/espresso/authdb/authdb_test.go
new file mode 100644
index 00000000000..0345f92adbc
--- /dev/null
+++ b/espresso/authdb/authdb_test.go
@@ -0,0 +1,61 @@
+package authdb
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/ethdb/dbtest"
+	"github.com/ethereum/go-ethereum/ethdb/memorydb"
+
+	espresso_tee_utils "github.com/offchainlabs/nitro/cmd/util/espresso-tee-utils"
+	"github.com/offchainlabs/nitro/util/testhelpers"
+)
+
+func Require(t *testing.T, err error, printables ...any) {
+	t.Helper()
+	testhelpers.RequireImpl(t, err, printables...)
+}
+
+func Assert(t *testing.T, cond bool, printables ...any) {
+	t.Helper()
+	if !cond {
+		testhelpers.FailImpl(t, printables...)
+	}
+}
+
+func RequireBench(b *testing.B, err error, printables ...any) {
+	b.Helper()
+	testhelpers.RequireImpl(b, err, printables...)
+}
+
+func TestAuthDB(t *testing.T) {
+	t.Run("AuthDBSuite", func(t *testing.T) {
+		dbtest.TestDatabaseSuite(t, func() ethdb.KeyValueStore {
+			db, err := rawdb.NewDatabaseWithFreezer(memorydb.New(), "authdbancient", "authdbtest", false)
+			Require(t, err)
+
+			hmac, err := espresso_tee_utils.HmacForTest()
+			Require(t, err)
+			authdb, err := NewAuthDB(db, hmac, false)
+			Require(t, err)
+
+			return &authdb
+		})
+	})
+
+}
+
+func BenchmarkAuthDB(b *testing.B) {
+	dbtest.BenchDatabaseSuite(b, func() ethdb.KeyValueStore {
+		db, err := rawdb.NewDatabaseWithFreezer(memorydb.New(), "authdbancient", "authdbtest", false)
+		RequireBench(b, err)
+
+		hmac, err := espresso_tee_utils.HmacForTest()
+		RequireBench(b, err)
+		authdb, err := NewAuthDB(db, hmac, false)
+		RequireBench(b, err)
+
+		return &authdb
+	})
+}
diff --git a/espresso/authdb/operations.go b/espresso/authdb/operations.go
new file mode 100644
index 00000000000..cf52f3806eb
--- /dev/null
+++ b/espresso/authdb/operations.go
@@ -0,0 +1,199 @@
+package authdb
+
+import (
+	"bytes"
+	"fmt"
+	"sort"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+// enforceAuthenticatedDB ensures that the db parameter is either *AuthDB or *AuthBatch
+// to guarantee that Put/Get operations are authenticated
+func enforceAuthenticatedWriter(db ethdb.KeyValueWriter) error {
+	switch db.(type) {
+	case *AuthDB, *AuthBatch:
+		return nil
+	default:
+		return fmt.Errorf("db must be *AuthDB or *AuthBatch to ensure authenticated operations, got %T", db)
+	}
+}
+
+func enforceAuthenticatedReader(db any) error {
+	switch db.(type) {
+	case *AuthDB, *AuthBatch:
+		return nil
+	default:
+		return fmt.Errorf("db must be *AuthDB or *AuthBatch to ensure authenticated operations, got %T", db)
+	}
+}
+
+// WriteNextHotshotBlockNum writes the next hotshot block number
+func WriteNextHotshotBlockNum(db ethdb.KeyValueWriter, num uint64) error {
+	if err := enforceAuthenticatedWriter(db); err != nil {
+		return err
+	}
+	return db.Put(nextHotshotBlockNumKey, EncodeUint64(num))
+}
+
+// ReadNextHotshotBlockNum reads the next hotshot block number
+func ReadNextHotshotBlockNum(db ethdb.KeyValueReader) (uint64, error) {
+	if err := enforceAuthenticatedReader(db); err != nil {
+		return 0, err
+	}
+	numBytes, err := db.Get(nextHotshotBlockNumKey)
+	if err != nil {
+		if rawdb.IsDbErrNotFound(err) {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("failed to get nextHotshotBlockNum: %w", err)
+	}
+	return DecodeUint64(numBytes)
+}
+
+// WriteFromBlock writes the delayed message fetcher's FromBlock info
+func WriteFromBlock(db ethdb.KeyValueWriter, fromBlk uint64) error {
+	if err := enforceAuthenticatedWriter(db); err != nil {
+		return err
+	}
+	return db.Put(fromBlockKey, EncodeUint64(fromBlk))
+}
+
+// ReadFromBlock reads the delayed message fetcher's FromBlock info
+func ReadFromBlock(db ethdb.KeyValueReader) (uint64, error) {
+	if err := enforceAuthenticatedReader(db); err != nil {
+		return 0, err
+	}
+	numBytes, err := db.Get(fromBlockKey)
+	if err != nil {
+		if rawdb.IsDbErrNotFound(err) {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("failed to get fromBlock: %w", err)
+	}
+	return DecodeUint64(numBytes)
+}
+
+// WriteEvents writes the batcher address monitor's Events info
+// We accept RLP-encoded events to avoid cyclic dependency since `BatcherAddrUpdate struct`
+// is defined in `arbnode` which will depend on this function
+func WriteEvents(db ethdb.KeyValueWriter, eventsBytes []byte) error {
+	if err := enforceAuthenticatedWriter(db); err != nil {
+		return err
+	}
+	return db.Put(eventsKey, eventsBytes)
+}
+
+// ReadEvents reads the batcher address monitor's Events info
+func ReadEvents(db ethdb.KeyValueReader) ([]byte, error) {
+	if err := enforceAuthenticatedReader(db); err != nil {
+		return nil, err
+	}
+	eventsBytes, err := db.Get(eventsKey)
+	if err != nil {
+		if rawdb.IsDbErrNotFound(err) {
+			// Returning (nil, nil) is intentional: absence of events is not an error, but indicates no events have been stored yet.
+			return nil, nil // nolint:nilerr
+		}
+		return nil, fmt.Errorf("failed to get events: %w", err)
+	}
+	return eventsBytes, nil
+}
+
+// WriteLastProcessedHeight writes the batcher address monitor's LastProcessedHeight info
+func WriteLastProcessedHeight(db ethdb.KeyValueWriter, height uint64) error {
+	if err := enforceAuthenticatedWriter(db); err != nil {
+		return err
+	}
+	return db.Put(lastProcessedHeightKey, EncodeUint64(height))
+}
+
+// ReadLastProcessedHeight reads the batcher address monitor's LastProcessedHeight info
+func ReadLastProcessedHeight(db ethdb.KeyValueReader) (uint64, error) {
+	if err := enforceAuthenticatedReader(db); err != nil {
+		return 0, err
+	}
+	heightBytes, err := db.Get(lastProcessedHeightKey)
+	if err != nil {
+		if rawdb.IsDbErrNotFound(err) {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("failed to get last processed height: %w", err)
+	}
+	return DecodeUint64(heightBytes)
+}
+
+type AddrFlag struct {
+	Addr common.Address
+	Flag bool
+}
+
+type AddrFlagList []AddrFlag
+
+func WriteAddresses(db ethdb.KeyValueWriter, addrs []map[common.Address]bool) error {
+	if err := enforceAuthenticatedWriter(db); err != nil {
+		return err
+	}
+
+	outer := make([]AddrFlagList, 0, len(addrs))
+
+	for _, m := range addrs {
+		list := make(AddrFlagList, 0, len(m))
+		for addr, flag := range m {
+			list = append(list, AddrFlag{
+				Addr: addr,
+				Flag: flag,
+			})
+		}
+
+		sort.Slice(list, func(i, j int) bool {
+			return bytes.Compare(
+				list[i].Addr.Bytes(),
+				list[j].Addr.Bytes(),
+			) < 0
+		})
+
+		outer = append(outer, list)
+	}
+
+	// Encode as RLP
+	encoded, err := rlp.EncodeToBytes(outer)
+	if err != nil {
+		return fmt.Errorf("failed to encode addresses: %w", err)
+	}
+
+	return db.Put(addressesKey, encoded)
+}
+
+func ReadAddresses(db ethdb.KeyValueReader) ([]map[common.Address]bool, error) {
+	// Read raw bytes
+	data, err := db.Get(addressesKey)
+	if err != nil {
+		if rawdb.IsDbErrNotFound(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	// Decode RLP -> [][]AddrFlag
+	var outer []AddrFlagList
+	if err := rlp.DecodeBytes(data, &outer); err != nil {
+		return nil, fmt.Errorf("failed to decode addresses: %w", err)
+	}
+
+	// Convert back to []map[Address]bool
+	result := make([]map[common.Address]bool, 0, len(outer))
+
+	for _, list := range outer {
+		m := make(map[common.Address]bool, len(list))
+		for _, af := range list {
+			m[af.Addr] = af.Flag
+		}
+		result = append(result, m)
+	}
+
+	return result, nil
+}
diff --git a/espresso/authdb/operations_test.go b/espresso/authdb/operations_test.go
new file mode 100644
index 00000000000..0b4c8b2dd84
--- /dev/null
+++ b/espresso/authdb/operations_test.go
@@ -0,0 +1,190 @@
+package authdb
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/ethdb/memorydb"
+
+	espresso_tee_utils "github.com/offchainlabs/nitro/cmd/util/espresso-tee-utils"
+)
+
+// make sure that CaffNode-specific operations that require authenticated DBs fail when given a plain reader/writer
+func TestAuthCaffNodeOperations(t *testing.T) {
+	// Create a plain memorydb (not AuthDB)
+	plainDB := rawdb.NewDatabase(memorydb.New())
+	defer plainDB.Close()
+
+	// Test writes with plain DB - should fail
+	err := WriteNextHotshotBlockNum(plainDB, 123)
+	Assert(t, err != nil, "expected error when writing NextHotshotBlockNum to plain db, but got nil")
+
+	err = WriteEvents(plainDB, []byte{0x01, 0x02, 0x03})
+	Assert(t, err != nil, "expected error when writing Events to plain db, but got nil")
+
+	err = WriteFromBlock(plainDB, 456)
+	Assert(t, err != nil, "expected error when writing FromBlock to plain db, but got nil")
+
+	err = WriteLastProcessedHeight(plainDB, 789)
+	Assert(t, err != nil, "expected error when writing LastProcessedHeight to plain db, but got nil")
+
+	// Test reads with plain DB - should fail
+	_, err = ReadNextHotshotBlockNum(plainDB)
+	Assert(t, err != nil, "expected error when reading NextHotshotBlockNum from plain db, but got nil")
+
+	_, err = ReadEvents(plainDB)
+	Assert(t, err != nil, "expected error when reading Events from plain db, but got nil")
+
+	_, err = ReadFromBlock(plainDB)
+	Assert(t, err != nil, "expected error when reading FromBlock from plain db, but got nil")
+
+	_, err = ReadLastProcessedHeight(plainDB)
+	Assert(t, err != nil, "expected error when reading LastProcessedHeight from plain db, but got nil")
+
+	// Test WriteAddresses with plain DB - should fail
+	plainAddrs := []map[common.Address]bool{
+		{
+			common.HexToAddress("0x1000000000000000000000000000000000000001"): true,
+		},
+	}
+	err = WriteAddresses(plainDB, plainAddrs)
+	Assert(t, err != nil, "expected error when writing addresses to plain db, but got nil")
+
+	// Test with plain batch - should fail
+	plainBatch := plainDB.NewBatch()
+
+	err = WriteNextHotshotBlockNum(plainBatch, 123)
+	Assert(t, err != nil, "expected error when writing NextHotshotBlockNum to plain batch, but got nil")
+
+	err = WriteEvents(plainBatch, []byte{0x01})
+	Assert(t, err != nil, "expected error when writing Events to plain batch, but got nil")
+
+	err = WriteFromBlock(plainBatch, 456)
+	Assert(t, err != nil, "expected error when writing FromBlock to plain batch, but got nil")
+
+	err = WriteLastProcessedHeight(plainBatch, 789)
+	Assert(t, err != nil, "expected error when writing LastProcessedHeight to plain batch, but got nil")
+
+	// Test WriteAddresses with plain batch - should fail
+	err = WriteAddresses(plainBatch, plainAddrs)
+	Assert(t, err != nil, "expected error when writing addresses to plain batch, but got nil")
+
+	hmac, err := espresso_tee_utils.HmacForTest()
+	Require(t, err)
+	authdb, err := NewAuthDB(plainDB, hmac, false)
+	Require(t, err)
+	defer authdb.Close()
+
+	// Test with AuthDB
+	err = WriteNextHotshotBlockNum(&authdb, 123)
+	Require(t, err)
+	value, err := ReadNextHotshotBlockNum(&authdb)
+	Require(t, err)
+	if value != 123 {
+		t.Fatalf("expected value 123, got %d", value)
+	}
+
+	err = WriteEvents(&authdb, []byte{0x01, 0x02, 0x03})
+	Require(t, err)
+	_, err = ReadEvents(&authdb)
+	Require(t, err)
+
+	// Test with AuthBatch
+	batch := authdb.NewBatch()
+
+	err = WriteFromBlock(batch, 456)
+	Require(t, err)
+	err = WriteLastProcessedHeight(batch, 789)
+	Require(t, err)
+	err = batch.Write()
+	Require(t, err)
+
+	fromBlk, err := ReadFromBlock(&authdb)
+	Require(t, err)
+	if fromBlk != 456 {
+		t.Fatalf("expected fromBlk 456, got %d", fromBlk)
+	}
+
+	lastBlk, err := ReadLastProcessedHeight(&authdb)
+	Require(t, err)
+	if lastBlk != 789 {
+		t.Fatalf("expected lastBlk 789, got %d", lastBlk)
+	}
+
+	// Test WriteAddresses / ReadAddresses with AuthDB and AuthBatch
+	a1 := common.HexToAddress("0x2000000000000000000000000000000000000001")
+	a2 := common.HexToAddress("0x2000000000000000000000000000000000000002")
+	a3 := common.HexToAddress("0x2000000000000000000000000000000000000003")
+
+	authAddrs := []map[common.Address]bool{
+		{
+			a1: true,
+			a2: false,
+		},
+		{
+			a3: true,
+		},
+	}
+
+	// Before writing, ReadAddresses on AuthDB should return nil, nil (no data)
+	addrRes, err := ReadAddresses(&authdb)
+	Require(t, err)
+	if addrRes != nil {
+		t.Fatalf("expected nil addresses before write, got %v", addrRes)
+	}
+
+	// Write using AuthDB
+	err = WriteAddresses(&authdb, authAddrs)
+	Require(t, err)
+
+	// Read back and compare
+	addrRes, err = ReadAddresses(&authdb)
+	Require(t, err)
+	if len(addrRes) != len(authAddrs) {
+		t.Fatalf("expected %d address lists, got %d", len(authAddrs), len(addrRes))
+	}
+	for i, expectedMap := range authAddrs {
+		gotMap := addrRes[i]
+		if len(gotMap) != len(expectedMap) {
+			t.Fatalf("index %d: expected %d addrs, got %d", i, len(expectedMap), len(gotMap))
+		}
+		for addr, flag := range expectedMap {
+			gotFlag, ok := gotMap[addr]
+			if !ok {
+				t.Fatalf("index %d: missing addr %s", i, addr.Hex())
+			}
+			if gotFlag != flag {
+				t.Fatalf("index %d: addr %s flag mismatch: expected %v, got %v", i, addr.Hex(), flag, gotFlag)
+			}
+		}
+	}
+
+	// Now test writing via AuthBatch
+	addrBatch := authdb.NewBatch()
+	err = WriteAddresses(addrBatch, authAddrs)
+	Require(t, err)
+	err = addrBatch.Write()
+	Require(t, err)
+
+	addrRes, err = ReadAddresses(&authdb)
+	Require(t, err)
+	if len(addrRes) != len(authAddrs) {
+		t.Fatalf("(batch) expected %d address lists, got %d", len(authAddrs), len(addrRes))
+	}
+	for i, expectedMap := range authAddrs {
+		gotMap := addrRes[i]
+		if len(gotMap) != len(expectedMap) {
+			t.Fatalf("(batch) index %d: expected %d addrs, got %d", i, len(expectedMap), len(gotMap))
+		}
+		for addr, flag := range expectedMap {
+			gotFlag, ok := gotMap[addr]
+			if !ok {
+				t.Fatalf("(batch) index %d: missing addr %s", i, addr.Hex())
+			}
+			if gotFlag != flag {
+				t.Fatalf("(batch) index %d: addr %s flag mismatch: expected %v, got %v", i, addr.Hex(), flag, gotFlag)
+			}
+		}
+	}
+}
diff --git a/espresso/authdb/schema.go b/espresso/authdb/schema.go
new file mode 100644
index 00000000000..609f6c0c7c5
--- /dev/null
+++ b/espresso/authdb/schema.go
@@ -0,0 +1,84 @@
+package authdb
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/core/rawdb"
+)
+
+// The fields below define which low level database schema prefixes our AuthDB will intercept in Get
+
+var (
+	// authenticated Geth
+	genericAuthTagSuffix = []byte("-tag")
+
+	// caff node specific
+	fromBlockKey           = []byte("fromBlk")
+	nextHotshotBlockNumKey = []byte("nextHsBlkNum")
+	addressesKey           = []byte("addresses")
+	eventsKey              = []byte("events2")
+	lastProcessedHeightKey = []byte("lastProcessedHeight")
+)
+
+// Tag Freezer Configuration
+// The tag freezer stores HMAC authentication tags in a separate ancient store
+// parallel to the main chain freezer. Each tag table corresponds to a main
+// ancient table and stores raw HMAC bytes indexed by the same item number.
+const (
+	// AuthTagFreezerName is the subfolder name for the tag ancient store
+	AuthTagFreezerName = "auth-tags"
+
+	// Tag table names - one per main ancient table
+	// These store raw HMAC tags corresponding to items in the main tables
+	AuthTagHashTable    = "tag-hashes"   // Tags for ChainFreezerHashTable
+	AuthTagHeaderTable  = "tag-headers"  // Tags for ChainFreezerHeaderTable
+	AuthTagBodiesTable  = "tag-bodies"   // Tags for ChainFreezerBodiesTable
+	AuthTagReceiptTable = "tag-receipts" // Tags for ChainFreezerReceiptTable
+)
+
+// Use the same size limit chain freezer (2GB)
+const tagFreezerTableSize = 2 * 1000 * 1000 * 1000
+
+// authTagTableNoSnappy configures compression for tag tables.
+// Tags are random HMAC outputs that don't compress well.
+var authTagTableNoSnappy = map[string]bool{
+	AuthTagHashTable:    true,
+	AuthTagHeaderTable:  true,
+	AuthTagBodiesTable:  true,
+	AuthTagReceiptTable: true,
+}
+
+// freezerTabletoTagTable maps main ancient table names to their corresponding tag table names
+var freezerTabletoTagTable = map[string]string{
+	rawdb.ChainFreezerHashTable:    AuthTagHashTable,
+	rawdb.ChainFreezerHeaderTable:  AuthTagHeaderTable,
+	rawdb.ChainFreezerBodiesTable:  AuthTagBodiesTable,
+	rawdb.ChainFreezerReceiptTable: AuthTagReceiptTable,
+}
+
+// getTagTable returns the tag table name for a given main ancient table kind
+func getTagTable(kind string) (string, bool) {
+	tagTable, ok := freezerTabletoTagTable[kind]
+	return tagTable, ok
+}
+
+func EncodeUint64(number uint64) []byte {
+	enc := make([]byte, 8)
+	binary.BigEndian.PutUint64(enc, number)
+	return enc
+}
+
+func DecodeUint64(enc []byte) (uint64, error) {
+	if len(enc) != 8 {
+		return 0, fmt.Errorf("invalid length")
+	}
+	var number uint64
+	err := binary.Read(bytes.NewReader(enc), binary.BigEndian, &number)
+	return number, err
+}
+
+func genericAuthTagKey(key []byte) []byte {
+	return append(key, genericAuthTagSuffix...)
+}
diff --git a/espresso/authdb/tag_freezer.go b/espresso/authdb/tag_freezer.go
new file mode 100644
index 00000000000..409bcf3018f
--- /dev/null
+++ b/espresso/authdb/tag_freezer.go
@@ -0,0 +1,40 @@
+package authdb
+
+import (
+	"path/filepath"
+
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+// newAuthTagFreezer creates a freezer instance dedicated to storing authentication tags.
+// The tag freezer is stored in a separate directory from the main chain freezer and
+// contains one table per main ancient table (hashes, headers, bodies, receipts).
+//
+// Parameters:
+//   - ancientDir: root ancient directory (empty string for in-memory mode)
+//   - readonly: whether to open in read-only mode
+//   - tables: map of table names to booleans indicating whether snappy compression is disabled
+//
+// Returns nil freezer (without error) if ancientDir is empty, allowing in-memory operation.
+func newAuthTagFreezerWithTables(ancientDir string, readonly bool, tables map[string]bool) (*rawdb.Freezer, error) {
+	if ancientDir == "" {
+		return nil, nil
+	}
+	tableWithConfigs := rawdb.NewEspressoTableConfig(tables)
+
+	tagFreezerDir := filepath.Join(ancientDir, AuthTagFreezerName)
+	tagFreezer, err := rawdb.NewFreezer(
+		tagFreezerDir,
+		"authdb/tags",
+		readonly,
+		tagFreezerTableSize,
+		tableWithConfigs,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Info("Opened authentication tag freezer", "path", tagFreezerDir, "readonly", readonly)
+	return tagFreezer, nil
+}
diff --git a/espresso/hotshot-listener/hotshot_listener.go b/espresso/hotshot-listener/hotshot_listener.go
new file mode 100644
index 00000000000..805e2dc2616
--- /dev/null
+++ b/espresso/hotshot-listener/hotshot_listener.go
@@ -0,0 +1,268 @@
+package hotshot_listener
+
+// import (
+// 	"context"
+// 	"fmt"
+// 	"math/big"
+// 	"strconv"
+
+// 	"github.com/EspressoSystems/espresso-network/sdks/go/types"
+// 	"github.com/gorilla/websocket"
+
+// 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+// 	"github.com/ethereum/go-ethereum/common"
+// 	"github.com/ethereum/go-ethereum/ethclient"
+// 	"github.com/ethereum/go-ethereum/log"
+
+// 	"github.com/offchainlabs/nitro/solgen/go/espressogen"
+// 	"github.com/offchainlabs/nitro/util/stopwaiter"
+// )
+
+// const (
+// 	HotshotListenerEndpoint = "/hotshot-events/events"
+// )
+
+// type HotshotListener struct {
+// 	stopwaiter.StopWaiter
+// 	hotshotUrl                        string
+// 	rollupSequencerManager            *espressogen.IEspressoRollupSequencerManager
+// 	quorumViewNumberBuilderCommitment map[string]big.Int
+// 	daViewNumberBuilderCommitment     map[string]bool
+// 	sequencerAddress                  string
+// 	conn                              *websocket.Conn
+// }
+
+// func NewHotshotListener(hotshotUrl string, rollupSequencerManagerContract string, l1Client *ethclient.Client, sequencerAddress string) (*HotshotListener, error) {
+
+// 	if hotshotUrl == "" {
+// 		return nil, fmt.Errorf("hotshot url is empty, please provide a valid url")
+// 	}
+// 	if rollupSequencerManagerContract == "" {
+// 		return nil, fmt.Errorf("rollup sequencer manager contract address is empty, please provide a valid address")
+// 	}
+// 	if sequencerAddress == "" {
+// 		return nil, fmt.Errorf("sequencer address is empty, please provide a valid address")
+// 	}
+// 	if l1Client == nil {
+// 		return nil, fmt.Errorf("l1 client is nil, please provide a valid client")
+// 	}
+
+// 	// Convert rollupSequencerManagerContract to an address
+// 	rollupSequencerManagerContractAddress := common.HexToAddress(rollupSequencerManagerContract)
+// 	rollupSequencerManager, err := espressogen.NewIEspressoRollupSequencerManager(rollupSequencerManagerContractAddress, l1Client)
+// 	if err != nil {
+// 		log.Error("failed to create rollup sequencer manager contract instance", "err", err)
+// 		return nil, err
+// 	}
+
+// 	// Create a new rollup sequencer manager contract instance
+// 	return &HotshotListener{
+// 		hotshotUrl:                        hotshotUrl + HotshotListenerEndpoint,
+// 		rollupSequencerManager:            rollupSequencerManager,
+// 		quorumViewNumberBuilderCommitment: make(map[string]big.Int),
+// 		daViewNumberBuilderCommitment:     make(map[string]bool),
+// 		sequencerAddress:                  sequencerAddress,
+// 	}, nil
+// }
+
+// func (listener *HotshotListener) processMessage(message []byte) error {
+// 	// Convert message to ConsensusMessage
+// 	consensusMessage, err := types.UnmarshalConsensusMessage(message)
+// 	if err != nil {
+// 		log.Error("failed to unmarshal consensus message:", err)
+// 		return err
+// 	}
+// 	// Quorum proposal represents a proposal that needs to be supported by a quorum of nodes
+// 	// this quorum proposal needs to be for a given view and builder commitment
+// 	if consensusMessage.Event.QuorumProposalWrapper != nil {
+// 		return listener.processQuorumProposalEvent(consensusMessage.Event.QuorumProposalWrapper)
+// 	}
+// 	// DA proposal event indicates thats data availability information
+// 	// is available for a given block with the given view number and builder commitment
+// 	if consensusMessage.Event.DaProposalWrapper != nil {
+// 		return listener.processDaProposalEvent(consensusMessage.Event.DaProposalWrapper)
+// 	}
+
+// 	// Only when hotshot builder has both quorum proposal and DA proposal for a given view
+// 	// it begins constructing another block
+// 	// Decide event in hotshot is the event when
+// 	// a view has been finalized by hotshot and cannot change now
+// 	if consensusMessage.Event.Decide != nil {
+// 		return listener.processDecideEvent(consensusMessage.Event.Decide)
+// 	}
+
+// 	return nil
+// }
+
+// func (listener *HotshotListener) processQuorumProposalEvent(quorumProposalWrapper *types.QuorumProposalWrapper) error {
+// 	log.Info("received quorum proposal event", "event", quorumProposalWrapper)
+
+// 	viewNumber := quorumProposalWrapper.QuorumProposalDataWrapper.Data.Proposal.ViewNumber
+// 	builderCommitment := quorumProposalWrapper.QuorumProposalDataWrapper.Data.Proposal.BlockHeader.Fields.BuilderCommitment
+
+// 	viewNumberString := strconv.Itoa(viewNumber)
+
+// 	// Combine the hexViewNumber and builderCommitment to get the key
+// 	key := viewNumberString + builderCommitment
+
+// 	l1FinalizedBlockNumberForView := quorumProposalWrapper.QuorumProposalDataWrapper.Data.Proposal.BlockHeader.Fields.L1Finalized.Number
+// 	l1FinalizedBlockNumberBigInt := big.NewInt(int64(l1FinalizedBlockNumberForView))
+// 	// Store the finalized L1 block number in the map
+// 	listener.quorumViewNumberBuilderCommitment[key] = *l1FinalizedBlockNumberBigInt
+
+// 	// Check if a da commitment exists for the key relative to
+// 	// this quorum proposal view number and builder commitment
+// 	if _, ok := listener.daViewNumberBuilderCommitment[key]; !ok {
+// 		log.Info("Waiting for Da proposal for the given builder commitment and view number", "viewNumber", viewNumber, "builderCommitment", builderCommitment)
+// 		return nil
+// 	}
+// 	log.Info("processing builder commitment and view number", "viewNumber", viewNumber, "builderCommitment", builderCommitment)
+
+// 	// Get the sequencer address for the next view
+// 	nextView := viewNumber + 1
+// 	// Note: Its important to use l1 finalized block number here because we want the GetCurrentSequencer to
+// 	// always return the same sequencer address for the same view number
+// 	sequencerAddressForNextView, err := listener.rollupSequencerManager.GetCurrentSequencer(&bind.CallOpts{
+// 		BlockNumber: l1FinalizedBlockNumberBigInt,
+// 	}, big.NewInt(int64(nextView)))
+// 	if err != nil {
+// 		log.Error("failed to get current sequencer", "err", err)
+// 		return err
+// 	}
+
+// 	if sequencerAddressForNextView.Hex() == listener.sequencerAddress {
+// 		log.Info("next view is this node's view", "nextView", nextView, "sequencerAddress", listener.sequencerAddress)
+// 		// TODO: Processing will be implemented in the next PR
+// 	}
+
+// 	// TODO: Processing will be implemented in the next PR
+
+// 	// Delete the quorum and da proposal keys from the map
+// 	// so that map doesnt take a lot of space in memory
+// 	delete(listener.quorumViewNumberBuilderCommitment, key)
+// 	delete(listener.daViewNumberBuilderCommitment, key)
+// 	return nil
+// }
+
+// func (listener *HotshotListener) processDaProposalEvent(daProposalWrapper *types.DaProposalWrapper) error {
+// 	log.Info("received DA Proposal event", "event", daProposalWrapper)
+
+// 	// Now get the view number for the given builder commitment
+// 	viewNumber := daProposalWrapper.DaProposalDataWrapper.Data.ViewNumber
+
+// 	viewNumberString := strconv.Itoa(viewNumber)
+
+// 	blockPayload, err := types.NewBlockPayload(daProposalWrapper.DaProposalDataWrapper.Data.EncodedTransactions,
+// 		daProposalWrapper.DaProposalDataWrapper.Data.Metadata)
+// 	if err != nil {
+// 		return err
+// 	}
+// 	builderCommitment, err := blockPayload.BuilderCommitment()
+// 	if err != nil {
+// 		return err
+// 	}
+
+// 	builderCommitmentString, err := builderCommitment.ToTaggedSting()
+// 	if err != nil {
+// 		log.Error("failed to convert builder commitment to tagged string:", err)
+// 		return err
+// 	}
+
+// 	key := viewNumberString + builderCommitmentString
+
+// 	// Now store the key and check if a quorum proposal exists for the given builder commitment
+// 	listener.daViewNumberBuilderCommitment[key] = true
+// 	// Check if a da commitment exists for this key
+// 	// relative to this DA proposal view number and builder commitment
+// 	if _, ok := listener.quorumViewNumberBuilderCommitment[key]; !ok {
+// 		// If it does, then we can assume that this is a DA proposal
+// 		log.Info("waiting for Quorum proposal for the given builder commitment and view number", "viewNumber", viewNumber, "builderCommitment", builderCommitmentString)
+// 		return nil
+// 	}
+
+// 	// Process the DA proposal and quorum proposal
+// 	log.Info("processing builder commitment and view number", "viewNumber", viewNumber, "builderCommitment", builderCommitmentString)
+
+// 	// Get L1 block number from the quorum proposal map
+// 	l1FinalizedBlockNumberForView := listener.quorumViewNumberBuilderCommitment[key]
+// 	nextView := viewNumber + 1
+// 	// Note: Its important to use l1 finalized block number here because we want the GetCurrentSequencer to
+// 	// always return the same sequencer address for the same view number
+// 	sequencerAddressForNextView, err := listener.rollupSequencerManager.GetCurrentSequencer(&bind.CallOpts{
+// 		BlockNumber: &l1FinalizedBlockNumberForView,
+// 	}, big.NewInt(int64(nextView)))
+// 	if err != nil {
+// 		log.Error("failed to get sequencer address for next view", "err", err)
+// 		return err
+// 	}
+
+// 	// Check if the sequencer address is the same address of this node
+// 	if sequencerAddressForNextView.Hex() != listener.sequencerAddress {
+// 		log.Info("next view is not this node's view")
+// 		// TODO: Processing will be implemented in the next PR
+// 	}
+
+// 	// TODO: Processing will be implemented in the next PR
+
+// 	// Delate the quorum and da proposal keys from the map
+// 	// so that map doesnt take a lot of space in memory
+// 	delete(listener.quorumViewNumberBuilderCommitment, key)
+// 	delete(listener.daViewNumberBuilderCommitment, key)
+// 	return nil
+
+// }
+
+// func (listener *HotshotListener) processDecideEvent(decide *types.Decide) error {
+// 	log.Info("Received Decide event", "event", decide)
+// 	for _, leafChain := range decide.LeafChain {
+// 		// Check if any of the leafs match the view number + builder commitment that we have stored
+// 		viewNumber := leafChain.Leaf.ViewNumber
+// 		builderCommitment := leafChain.Leaf.BlockHeader.Fields.BuilderCommitment
+// 		log.Info("processing leaf chain", "leafChain", leafChain, "builderCommitment", builderCommitment, "viewNumber", viewNumber)
+// 		// TODO: Processing will be implemented in the next PR
+
+// 	}
+// 	return nil
+// }
+
+// func (listener *HotshotListener) Start(ctx context.Context) error {
+// 	listener.StopWaiter.Start(ctx, listener)
+// 	conn, _, err := websocket.DefaultDialer.Dial(listener.hotshotUrl, nil)
+// 	if err != nil {
+// 		log.Error("failed to connect to hotshot webSocket", "err", err)
+// 		return err
+// 	}
+// 	listener.conn = conn
+
+// 	// Launch thread to listen to new messages from the websocket
+// 	listener.LaunchThread(func(ctx context.Context) {
+// 		for {
+// 			select {
+// 			case <-ctx.Done():
+// 				listener.conn.Close()
+// 				return
+// 			default:
+// 			}
+// 			_, message, err := listener.conn.ReadMessage()
+// 			if err != nil {
+// 				log.Error("error reading message", "err", err)
+// 				continue
+// 			}
+// 			err = listener.processMessage(message)
+// 			if err != nil {
+// 				log.Error("error processing message", "err", err)
+// 				continue
+// 			}
+// 		}
+// 	})
+
+// 	return nil
+// }
+
+// func (listener *HotshotListener) StopAndWait() {
+// 	err := listener.conn.Close()
+// 	if err != nil {
+// 		log.Error("failed to close websocket connection", "err", err)
+// 	}
+// 	listener.StopWaiter.StopAndWait()
+// }
diff --git a/espresso/key-manager/key_manager.go b/espresso/key-manager/key_manager.go
new file mode 100644
index 00000000000..856abbb0b18
--- /dev/null
+++ b/espresso/key-manager/key_manager.go
@@ -0,0 +1,484 @@
+package keymanager
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"errors"
+	"fmt"
+	"math/big"
+
+	"github.com/hf/nsm"
+	"github.com/hf/nsm/request"
+
+	"github.com/ethereum/go-ethereum/common/math"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/signer/core/apitypes"
+
+	"github.com/offchainlabs/nitro/arbnode/dataposter"
+	espresso_tee_utils "github.com/offchainlabs/nitro/cmd/util/espresso-tee-utils"
+	attestationverifierclient "github.com/offchainlabs/nitro/espresso/attestation_verifier_client"
+	"github.com/offchainlabs/nitro/espressotee"
+	"github.com/offchainlabs/nitro/util/signature"
+)
+
+const (
+	NITRO = espressotee.NITRO
+	TESTS = espressotee.TESTS
+	EMPTY = espressotee.EMPTY
+)
+
+var FatalErrUnableToRegisterSigner = errors.New("unable to register signer")
+
+type KeyManagerState int
+
+const (
+	Init KeyManagerState = iota
+	PendingDataPosterSync
+	PendingRegistration
+	Registered
+)
+
+type state struct {
+	currentState KeyManagerState
+	attestation  []byte
+	data         []byte
+}
+
+var TestEspressoPrivateKey *ecdsa.PrivateKey
+
+func init() {
+	// Hardcoded test private key (DO NOT use in production)
+	// This is a private key derived from the test test test ... test junk BIP-39 mnemonic. It is a well known private key, so it should be fine to hardcode for tests.
+	// I found it here: https://ethereum.stackexchange.com/questions/147078/hardhat-which-file-is-initial-state-in-such-as-the-mnemonic-and-20-accounts
+	key, err := crypto.HexToECDSA("ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80")
+	if err != nil {
+		panic(err)
+	}
+	TestEspressoPrivateKey = key
+}
+
+type EspressoKeyManagerInterface interface {
+	GetCurrentKey() *ecdsa.PublicKey
+	SignPayload(message []byte) ([]byte, error)
+	SignMessage(message []byte) ([]byte, error)
+	TeeType() espressotee.TEE
+	GetKeyManagerState() KeyManagerState
+	CheckRegistration() (bool, error)
+}
+
+var _ EspressoKeyManagerInterface = &EspressoKeyManager{}
+
+type EspressoKeyManager struct {
+	espressoTEEVerifierCaller espressotee.EspressoTEEVerifierInterface
+	privKey                   *ecdsa.PrivateKey
+
+	signer      signature.DataSignerFunc
+	dataPoster  *dataposter.DataPoster
+	teeType     espressotee.TEE
+	serviceType espressotee.ServiceType
+
+	espressoNitroAttestationVerifierClient *attestationverifierclient.EspressoAttestationVerifierClient
+	parentChainId                          uint64
+	state                                  state
+}
+
+func NewEspressoKeyManager(
+	espressoTEEVerifierCaller espressotee.EspressoTEEVerifierInterface,
+	dataPoster *dataposter.DataPoster,
+	signerFunc signature.DataSignerFunc,
+	teeType espressotee.TEE,
+	serviceType espressotee.ServiceType,
+	servicePersistentPrivateKey *ecdsa.PrivateKey,
+	zkAttestationServiceURL string,
+	keyPairAttestationsPath string,
+	chainID uint64,
+) *EspressoKeyManager {
+	var err error
+	var privKey *ecdsa.PrivateKey
+
+	// Both the caff node and batch poster support persistent private keys. If an existing private key
+	// is provided, we use that one. Otherwise, we read the enclave private key from the attestation path.
+	// Note: The current implementation only supports reading the key during key manager construction
+	// for the batch poster. Support for reading the caff node key will be added in a later PR.
+	if keyPairAttestationsPath != "" && chainID != 0 {
+		// Read enclave private key
+		privKey, err = espresso_tee_utils.ReadEnclavePrivateKey(keyPairAttestationsPath, chainID)
+		if err != nil {
+			log.Crit("error reading enclave private key for Espresso Key Manager", "path", keyPairAttestationsPath, "err", err)
+		}
+
+	} else if servicePersistentPrivateKey != nil {
+		privKey = servicePersistentPrivateKey
+	} else if teeType == espressotee.TESTS {
+		privKey = TestEspressoPrivateKey
+	} else {
+		panic("either keyPairAttestationsPath and chainID must be provided, or servicePersistentPrivateKey must be non-nil")
+	}
+
+	// Production guard: TESTS with a non-Test serviceType would register the test key unattested.
+	if teeType == TESTS && serviceType != espressotee.Test {
+		panic(fmt.Sprintf("fatal misconfiguration: TeeType=TESTS requires serviceType=Test, got serviceType=%v", serviceType))
+	}
+
+	if signerFunc == nil && serviceType != espressotee.CaffNode && serviceType != espressotee.Test {
+		panic("DataSigner is nil")
+	}
+
+	if teeType == NITRO && zkAttestationServiceURL == "" {
+		if serviceType != espressotee.Test {
+			panic("zk attestation service URL must be provided for nitro TEE type")
+		} else {
+			log.Info("Allowing nitro key manager creation without zkAttestationServiceURL for tests")
+		}
+	}
+
+	espressoNitroAttestationVerifierClient := attestationverifierclient.NewEspressoAttestationVerifierClient(zkAttestationServiceURL)
+	parentChainId, err := espressoTEEVerifierCaller.ParentChainId()
+	if err != nil {
+		log.Crit("failed to get parent chain ID", "err", err)
+	}
+
+	return &EspressoKeyManager{
+		privKey:                                privKey,
+		signer:                                 signerFunc,
+		espressoTEEVerifierCaller:              espressoTEEVerifierCaller,
+		dataPoster:                             dataPoster,
+		teeType:                                teeType,
+		serviceType:                            serviceType,
+		espressoNitroAttestationVerifierClient: espressoNitroAttestationVerifierClient,
+		parentChainId:                          parentChainId,
+		state: state{
+			currentState: Init,
+			attestation:  []byte{},
+			data:         []byte{},
+		},
+	}
+}
+
+// Contract only accepts NITRO; TESTS → NITRO.
+func (k *EspressoKeyManager) onChainTeeType() espressotee.TEE {
+	if k.teeType == TESTS {
+		return NITRO
+	}
+	return k.teeType
+}
+
+// Contract only accepts BatchPoster/CaffNode; infer from signer presence when in TESTS.
+func (k *EspressoKeyManager) onChainServiceType() espressotee.ServiceType {
+	if k.teeType == TESTS {
+		if k.signer != nil {
+			return espressotee.BatchPoster
+		}
+		return espressotee.CaffNode
+	}
+	return k.serviceType
+}
+
+func (k *EspressoKeyManager) hasRegistered() bool {
+	return k.state.currentState == Registered
+}
+
+func (k *EspressoKeyManager) GetKeyManagerState() KeyManagerState {
+	return k.state.currentState
+}
+
+func (k *EspressoKeyManager) verifyRegistrationOnChain() (bool, error) {
+	if k.hasRegistered() {
+		return true, nil
+	}
+	pubKey, ok := k.privKey.Public().(*ecdsa.PublicKey)
+	if !ok {
+		panic("failed to get public key")
+	}
+	signerAddr := crypto.PubkeyToAddress(*pubKey)
+	ok, err := k.espressoTEEVerifierCaller.RegisteredServices(signerAddr, k.onChainTeeType())
+	if err != nil {
+		return false, err
+	}
+	return ok, nil
+}
+
+func (k *EspressoKeyManager) CheckRegistration() (bool, error) {
+	state := k.state.currentState
+	switch state {
+	case Init:
+		log.Warn("ephemeral keys are not yet registered in Espresso TEE Contract, KeyManager in Init phase. Waiting for Zk proof to be generated")
+		newState, err := k.init()
+		if err != nil {
+			return false, fmt.Errorf("unable to init keymanager: %w", err)
+		}
+		k.state = *newState
+		if k.hasRegistered() {
+			signerAddr := crypto.PubkeyToAddress(k.privKey.PublicKey)
+			log.Info("Signer already registered on-chain", "signer address", signerAddr.Hex())
+			return true, nil
+		}
+		return false, nil
+	case PendingDataPosterSync:
+		log.Warn("ephemeral keys are not yet registered in Espresso TEE Contract, KeyManager in Data Poster sync phase")
+		err := k.pendingDataPosterSync()
+		if err != nil {
+			return false, fmt.Errorf("data poster nonce and l1 nonce still mismatch: %w", err)
+		}
+		k.state.currentState = PendingRegistration
+		return false, nil
+	case PendingRegistration:
+		log.Warn("ephemeral keys are not yet registered in Espresso TEE Contract, KeyManager in Registration phase")
+		err := k.registerService()
+		if err != nil {
+			return false, fmt.Errorf("%w: %w", FatalErrUnableToRegisterSigner, err)
+		}
+		// We are registered free up the memory
+		k.state.currentState = Registered
+		k.state.attestation = []byte{}
+		k.state.data = []byte{}
+		return true, nil
+	case Registered:
+		return true, nil
+	default:
+		return false, fmt.Errorf("key manager in an unknown state: %v", state)
+	}
+}
+
+/*
+ * This function will get the attestation in order to properly register the signing address on chain for a given TEE type
+ */
+func (k *EspressoKeyManager) prepareRegisterService(getAttestationFunc func([]byte) ([]byte, error)) ([]byte, []byte, error) {
+	pubKey := k.privKey.PublicKey
+	signerAddr := crypto.PubkeyToAddress(pubKey)
+	switch k.teeType {
+	case NITRO:
+		pubKeyBytes := crypto.FromECDSAPub(&pubKey)
+		log.Info("nitro signing address", "addr", signerAddr)
+
+		attestationBytes, err := getAttestationFunc(pubKeyBytes)
+		if err != nil {
+			return nil, nil, fmt.Errorf("nitro signing failed: %w", err)
+		}
+		if k.espressoNitroAttestationVerifierClient == nil {
+			return nil, nil, errors.New("attestation verifier client is not initialized")
+		}
+		// this condition is only possible in tests where we want to skip attestation verification.
+		if len(attestationBytes) == 0 {
+			return nil, nil, nil
+		}
+		journalBytes, onchainProofBytes, err := k.espressoNitroAttestationVerifierClient.GenerateZKProof(context.Background(), attestationBytes)
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to generate zk proof from nitro attestation: %w", err)
+		}
+
+		log.Info("successfully generated zk proof from nitro attestation")
+		return journalBytes, onchainProofBytes, nil
+	case TESTS:
+		pubKey := crypto.FromECDSAPub(&k.privKey.PublicKey)
+		log.Info("TESTS signing address", "addr", signerAddr)
+
+		attestationQuote, err := getAttestationFunc(pubKey)
+		if err != nil {
+			return nil, nil, fmt.Errorf("TESTS signing failed: %w", err)
+		}
+		// TESTS maps to NITRO on-chain; Nitro mock expects `output` to be an
+		// ABI-encoded VerifierJournal containing the signer public key.
+		journalBytes, err := k.encodeNitroMockJournalByService(attestationQuote)
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to encode Nitro mock VerifierJournal for TESTS registration: %w", err)
+		}
+		// Proof bytes are ignored by the Nitro mock.
+		return journalBytes, []byte{}, nil
+	default:
+		return nil, nil, fmt.Errorf("unsupported TEE type: %v", k.teeType)
+	}
+}
+
+func (k *EspressoKeyManager) encodeNitroMockJournalByService(publicKey []byte) ([]byte, error) {
+	if k.onChainServiceType() == espressotee.BatchPoster {
+		return encodeNitroMockBatchPosterVerifierJournalPublicKey(publicKey)
+	}
+	return encodeNitroMockCaffNodeVerifierJournalPublicKey(publicKey)
+}
+
+func encodeNitroMockBatchPosterVerifierJournalPublicKey(publicKey []byte) ([]byte, error) {
+	return espressotee.EncodeNitroMockVerifierJournalPublicKey(publicKey)
+}
+
+func encodeNitroMockCaffNodeVerifierJournalPublicKey(publicKey []byte) ([]byte, error) {
+	return espressotee.EncodeNitroMockVerifierJournalPublicKey(publicKey)
+}
+
+func (k *EspressoKeyManager) initRegistration(getAttestationFunc func([]byte) ([]byte, error)) (*state, error) {
+	hasRegistered, err := k.verifyRegistrationOnChain()
+	if err != nil {
+		return nil, err
+	}
+	if hasRegistered {
+		return &state{
+			currentState: Registered,
+			attestation:  []byte{},
+			data:         []byte{},
+		}, nil
+	}
+
+	// Get the attestation and data needed to register the signer
+	attestation, data, err := k.prepareRegisterService(getAttestationFunc)
+	if err != nil {
+		return nil, err
+	}
+
+	return &state{
+		data:         data,
+		attestation:  attestation,
+		currentState: PendingDataPosterSync,
+	}, nil
+}
+
+func (k *EspressoKeyManager) pendingDataPosterSync() error {
+	currentState := k.GetKeyManagerState()
+	if currentState != PendingDataPosterSync {
+		return fmt.Errorf("invalid state to check data poster sync: got %v, want PendingDataPosterSync", currentState)
+	}
+	err := k.espressoTEEVerifierCaller.CheckNonceValidation(k.dataPoster)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (k *EspressoKeyManager) registerService() error {
+	currentState := k.GetKeyManagerState()
+	if currentState != PendingRegistration {
+		return fmt.Errorf("invalid state to register signer: got %v, want PendingRegistration", currentState)
+	}
+	err := k.espressoTEEVerifierCaller.RegisterService(k.dataPoster, k.state.attestation, k.state.data, uint8(k.onChainTeeType()))
+	if err != nil {
+		return err
+	}
+
+	signerAddr := crypto.PubkeyToAddress(k.privKey.PublicKey)
+	log.Info("Register signer transaction sent", "signer address", signerAddr.Hex())
+
+	// Verify our address is actually registered in contract
+	hasRegistered, err := k.verifyRegistrationOnChain()
+	if err != nil {
+		return err
+	}
+	if !hasRegistered {
+		return errors.New("address is not registered in contract even after successful transaction and retries")
+	}
+
+	log.Info("Signer registration confirmed on-chain")
+	return nil
+}
+
+func (k *EspressoKeyManager) GetCurrentKey() *ecdsa.PublicKey {
+	return &k.privKey.PublicKey
+}
+
+// Returns the on-chain tee type (callers building payloads need to match the contract).
+func (k *EspressoKeyManager) TeeType() espressotee.TEE {
+	return k.onChainTeeType()
+}
+
+func (k *EspressoKeyManager) SignPayload(message []byte) ([]byte, error) {
+	return k.signer(crypto.Keccak256Hash(message).Bytes())
+}
+
+// SignMessage uses the ephemeral/persistent private key which is generated inside the TEE to sign the EIP-712 message
+func (k *EspressoKeyManager) SignMessage(message []byte) ([]byte, error) {
+	return SignTypedMessage(message, k.privKey, k.parentChainId, k.espressoTEEVerifierCaller.EspressoTEEAddress().Hex())
+}
+
+func (k *EspressoKeyManager) init() (*state, error) {
+	// Dispatch on configured tee type, not on-chain: TESTS needs noOpSignerFunc.
+	switch k.teeType {
+	case NITRO:
+		return k.initRegistration(k.getNitroAttestation)
+	case TESTS:
+		return k.initRegistration(k.noOpSignerFunc)
+	default:
+		return nil, fmt.Errorf("unsupported tee Type: %d", k.teeType)
+	}
+}
+
+// getNitroAttestation is a method that retrieves the attestation document for
+// AWS Nitro Enclaves.
+// This function gets the attestation document for AWS Nitro Enclaves
+// We retrieve the Attestation using our epheremal public key we created in EspressoKeyManager
+// After we retrieve, we verify the attestation, where we retrieve the result
+// Which will contain the complete attestation which we serialize for further processing
+func (k *EspressoKeyManager) getNitroAttestation(pubKey []byte) ([]byte, error) {
+
+	sess, err := nsm.OpenDefaultSession()
+	if err != nil {
+		return nil, fmt.Errorf("failed to open nsm session: %w", err)
+	}
+	defer sess.Close()
+
+	res, err := sess.Send(&request.Attestation{
+		PublicKey: pubKey,
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to send attestation request: %w", err)
+	}
+
+	if res.Error != "" {
+		return nil, fmt.Errorf("nsm returned error: %s", res.Error)
+	}
+
+	if res.Attestation == nil || res.Attestation.Document == nil {
+		return nil, fmt.Errorf("no attestation document returned")
+	}
+
+	return res.Attestation.Document, nil
+}
+
+// No-Op Signauture
+// This is a function designed to replace a signing function for functionality that depends on operating in a TEE
+func (k *EspressoKeyManager) noOpSignerFunc(addr []byte) ([]byte, error) {
+	return addr, nil
+}
+
+func SignTypedMessage(message []byte, privKey *ecdsa.PrivateKey, parentChainId uint64, contract string) ([]byte, error) {
+	messageHash := crypto.Keccak256(message)
+	typedData := apitypes.TypedData{
+		Types: apitypes.Types{
+			"EIP712Domain": []apitypes.Type{
+				{Name: "name", Type: "string"},
+				{Name: "version", Type: "string"},
+				{Name: "chainId", Type: "uint256"},
+				{Name: "verifyingContract", Type: "address"},
+			},
+			"EspressoTEEVerifier": []apitypes.Type{
+				{Name: "commitment", Type: "bytes32"},
+			},
+		},
+		PrimaryType: "EspressoTEEVerifier",
+		Domain: apitypes.TypedDataDomain{
+			Name:              "EspressoTEEVerifier",
+			Version:           "1",
+			ChainId:           (*math.HexOrDecimal256)(new(big.Int).SetUint64(parentChainId)),
+			VerifyingContract: contract,
+		},
+		Message: map[string]interface{}{
+			"commitment": messageHash[:32],
+		},
+	}
+	// Calculate the hash using go-ethereum's EIP-712 implementation
+	hash, _, err := apitypes.TypedDataAndHash(typedData)
+	if err != nil {
+		return nil, fmt.Errorf("failed to calculate EIP-712 hash: %w", err)
+	}
+
+	signature, err := crypto.Sign(hash, privKey)
+	if err != nil {
+		return nil, fmt.Errorf("failed to sign EIP-712 hash: %w", err)
+	}
+
+	// Normalize the recovery ID (v) from 0/1 to 27/28 for Solidity's ECDSA.recover
+	// See: https://github.com/ethereum/go-ethereum/issues/19751#issuecomment-504900739
+	if signature[64] < 27 {
+		signature[64] += 27
+	}
+	return signature, nil
+}
diff --git a/espresso/key-manager/key_manager_test.go b/espresso/key-manager/key_manager_test.go
new file mode 100644
index 00000000000..1f81779a7b9
--- /dev/null
+++ b/espresso/key-manager/key_manager_test.go
@@ -0,0 +1,271 @@
+package keymanager_test
+
+import (
+	"crypto/ecdsa"
+	"encoding/hex"
+	"fmt"
+	"math/big"
+	"testing"
+
+	hdwallet "github.com/miguelmota/go-ethereum-hdwallet"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/math"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/signer/core/apitypes"
+
+	"github.com/offchainlabs/nitro/arbnode/dataposter"
+	espresso_key_manager "github.com/offchainlabs/nitro/espresso/key-manager"
+	"github.com/offchainlabs/nitro/espressotee"
+)
+
+type mockEspressoTEEVerifier struct {
+	mock.Mock
+}
+
+func (m *mockEspressoTEEVerifier) RegisterService(dataPoster *dataposter.DataPoster, attestation []byte, data []byte, teeType uint8) error {
+	args := m.Called(dataPoster, attestation, data, teeType)
+	return args.Error(0)
+}
+
+func (m *mockEspressoTEEVerifier) RegisteredServices(addr common.Address, teeType espressotee.TEE) (bool, error) {
+	args := m.Called(addr)
+	return args.Bool(0), nil
+}
+
+func (m *mockEspressoTEEVerifier) EspressoTEEAddress() common.Address {
+	args := m.Called()
+	addr, _ := args.Get(0).(common.Address)
+	return addr
+}
+
+func (m *mockEspressoTEEVerifier) ParentChainId() (uint64, error) {
+	args := m.Called()
+	val, _ := args.Get(0).(uint64)
+	return val, args.Error(1)
+}
+
+func (m *mockEspressoTEEVerifier) CheckNonceValidation(dataPoster *dataposter.DataPoster) error {
+	args := m.Called(dataPoster)
+	return args.Error(0)
+}
+
+type mockNitroEspressoTEEVerifier struct {
+	mock.Mock
+}
+
+func (m *mockNitroEspressoTEEVerifier) IsPCR0HashRegistered(pcr0Hash [32]byte) (bool, error) {
+	args := m.Called(pcr0Hash)
+	return true, args.Error(0)
+}
+
+func TestEspressoKeyManager(t *testing.T) {
+	privKey := "1234567890abcdef1234567890abcdef12345678000000000000000000000000"
+	const parentChainID uint64 = 1
+	verifierAddress := common.HexToAddress("0x0000000000000000000000000000000000000001")
+
+	_, signer, err := GetTransactOptsAndSigner(privKey, big.NewInt(1))
+	require.NoError(t, err, "Should open wallet")
+	dataSigner := func(data []byte) ([]byte, error) { return signer(data) }
+	dataposter := &dataposter.DataPoster{}
+	mockEspressoNitroTEEVerifier := new(mockNitroEspressoTEEVerifier)
+	mockEspressoNitroTEEVerifier.On("IsPCR0HashRegistered", mock.Anything).Return(true, nil)
+
+	// Generate persistent private key from test mnemonic for tests that need it
+	testMnemonic := "test test test test test test test test test test test junk"
+	persistentPrivKey := GeneratePrivateKeyFromMnemonic(t, testMnemonic, 0)
+
+	t.Run("Nitro Registry", func(t *testing.T) {
+		mockEspressoTEEVerifierClient := new(mockEspressoTEEVerifier)
+		mockEspressoTEEVerifierClient.On("ParentChainId").Return(parentChainID, nil)
+		mockEspressoTEEVerifierClient.On("EspressoTEEAddress").Return(verifierAddress)
+		mockEspressoTEEVerifierClient.On("RegisterService", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
+		mockEspressoTEEVerifierClient.On("RegisteredServices", mock.Anything).Return(false, nil).Once()
+		mockEspressoTEEVerifierClient.On("RegisteredServices", mock.Anything).Return(true, nil).Once()
+		mockEspressoTEEVerifierClient.On("CheckNonceValidation", mock.Anything).Return(nil)
+		km := espresso_key_manager.NewEspressoKeyManager(mockEspressoTEEVerifierClient, dataposter, dataSigner, espresso_key_manager.TESTS, espressotee.Test, nil, "", "", 0)
+		assert.Equal(t, espresso_key_manager.Init, km.GetKeyManagerState(), "Should start unregistered")
+
+		// Init → PendingDataPosterSync
+		registered, err := km.CheckRegistration()
+		require.NoError(t, err)
+		assert.False(t, registered)
+		assert.Equal(t, espresso_key_manager.PendingDataPosterSync, km.GetKeyManagerState())
+
+		// PendingDataPosterSync → PendingRegistration
+		registered, err = km.CheckRegistration()
+		require.NoError(t, err)
+		assert.False(t, registered)
+		assert.Equal(t, espresso_key_manager.PendingRegistration, km.GetKeyManagerState())
+
+		// PendingRegistration → Registered
+		registered, err = km.CheckRegistration()
+		require.NoError(t, err)
+		assert.True(t, registered)
+		assert.Equal(t, espresso_key_manager.Registered, km.GetKeyManagerState())
+	})
+
+	// Test Sign
+	t.Run("Nitro SignMessage with the ephemeral key", func(t *testing.T) {
+		mockEspressoTEEVerifierClient := new(mockEspressoTEEVerifier)
+		mockEspressoTEEVerifierClient.On("ParentChainId").Return(parentChainID, nil)
+		mockEspressoTEEVerifierClient.On("EspressoTEEAddress").Return(verifierAddress)
+		mockEspressoTEEVerifierClient.On("RegisterService", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
+		mockEspressoTEEVerifierClient.On("RegisteredServices", mock.Anything).Return(false, nil).Once()
+		km := espresso_key_manager.NewEspressoKeyManager(mockEspressoTEEVerifierClient, dataposter, dataSigner, espresso_key_manager.NITRO, espressotee.Test, persistentPrivKey, "", "", 0)
+		message := []byte("test-message")
+		signature, err := km.SignMessage(message)
+		require.NoError(t, err, "Sign should succeed")
+		assert.NotEmpty(t, signature, "Signature should not be empty")
+
+		ecdsaPubkey := km.GetCurrentKey()
+		valid, err := VerifyEIP712SignatureWithPublicKey(ecdsaPubkey, message, signature, parentChainID, verifierAddress)
+		require.NoError(t, err, "Should verify signature")
+		assert.True(t, valid, "Signature should verify with public key")
+	})
+
+	t.Run("Nitro Sign Hotshot payload with batcher private key", func(t *testing.T) {
+		mockEspressoTEEVerifierClient := new(mockEspressoTEEVerifier)
+		mockEspressoTEEVerifierClient.On("ParentChainId").Return(parentChainID, nil)
+		mockEspressoTEEVerifierClient.On("EspressoTEEAddress").Return(verifierAddress)
+		mockEspressoTEEVerifierClient.On("RegisterService", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
+		mockEspressoTEEVerifierClient.On("RegisteredServices", mock.Anything).Return(false, nil).Once()
+		km := espresso_key_manager.NewEspressoKeyManager(mockEspressoTEEVerifierClient, dataposter, dataSigner, espresso_key_manager.NITRO, espressotee.Test, persistentPrivKey, "", "", 0)
+		message := []byte("test-message")
+		signature, err := km.SignPayload(message)
+		require.NoError(t, err, "Sign should succeed")
+
+		privKeyBytes, err := hex.DecodeString(privKey)
+		assert.NoError(t, err, "Should decode private key")
+		pk, err := crypto.ToECDSA(privKeyBytes)
+		assert.NoError(t, err, "Should convert private key to ECDSA")
+
+		ecdsaPubkey, ok := pk.Public().(*ecdsa.PublicKey)
+		require.True(t, ok, "Public key should be an ecdsa.PublicKey")
+		valid, err := VerifySignatureWithPublicKey(ecdsaPubkey, message, signature)
+		require.NoError(t, err, "Should verify signature")
+		assert.True(t, valid, "Signature should verify with public key")
+	})
+}
+
+func TestEspressoKeyManagerTestsTeeTypeServiceTypeValidation(t *testing.T) {
+	mockClient := new(mockEspressoTEEVerifier)
+	mockClient.On("ParentChainId").Return(uint64(1), nil)
+	mockClient.On("EspressoTEEAddress").Return(common.Address{})
+
+	_, signer, err := GetTransactOptsAndSigner("1234567890abcdef1234567890abcdef12345678000000000000000000000000", big.NewInt(1))
+	require.NoError(t, err)
+	dataSigner := func(data []byte) ([]byte, error) { return signer(data) }
+
+	newKM := func(sig func([]byte) ([]byte, error), svc espressotee.ServiceType) {
+		espresso_key_manager.NewEspressoKeyManager(
+			mockClient, &dataposter.DataPoster{}, sig,
+			espresso_key_manager.TESTS, svc,
+			nil, "", "", 0,
+		)
+	}
+
+	// TESTS paired with a production service type is a fatal misconfiguration.
+	require.Panics(t, func() { newKM(dataSigner, espressotee.BatchPoster) })
+	require.Panics(t, func() { newKM(nil, espressotee.CaffNode) })
+
+	// TESTS + Test is the only valid test configuration (either signer flavor).
+	require.NotPanics(t, func() { newKM(dataSigner, espressotee.Test) })
+	require.NotPanics(t, func() { newKM(nil, espressotee.Test) })
+}
+
+func VerifySignatureWithPublicKey(publicKey *ecdsa.PublicKey, data []byte, signature []byte) (bool, error) {
+	hash := crypto.Keccak256Hash(data)
+
+	recoveredPubKey, err := crypto.SigToPub(hash.Bytes(), signature)
+	if err != nil {
+		return false, err
+	}
+
+	matches := recoveredPubKey.Equal(publicKey)
+	return matches, nil
+}
+
+func VerifyEIP712SignatureWithPublicKey(publicKey *ecdsa.PublicKey, data []byte, signature []byte, chainID uint64, verifierAddress common.Address) (bool, error) {
+	messageHash := crypto.Keccak256(data)
+	typedData := apitypes.TypedData{
+		Types: apitypes.Types{
+			"EIP712Domain": []apitypes.Type{
+				{Name: "name", Type: "string"},
+				{Name: "version", Type: "string"},
+				{Name: "chainId", Type: "uint256"},
+				{Name: "verifyingContract", Type: "address"},
+			},
+			"EspressoTEEVerifier": []apitypes.Type{
+				{Name: "commitment", Type: "bytes32"},
+			},
+		},
+		PrimaryType: "EspressoTEEVerifier",
+		Domain: apitypes.TypedDataDomain{
+			Name:              "EspressoTEEVerifier",
+			Version:           "1",
+			ChainId:           (*math.HexOrDecimal256)(new(big.Int).SetUint64(chainID)),
+			VerifyingContract: verifierAddress.Hex(),
+		},
+		Message: map[string]interface{}{
+			"commitment": messageHash[:32],
+		},
+	}
+
+	hash, _, err := apitypes.TypedDataAndHash(typedData)
+	if err != nil {
+		return false, err
+	}
+
+	recoverableSig := append([]byte(nil), signature...)
+	if len(recoverableSig) == 65 && recoverableSig[64] >= 27 {
+		recoverableSig[64] -= 27
+	}
+
+	recoveredPubKey, err := crypto.SigToPub(hash, recoverableSig)
+	if err != nil {
+		return false, err
+	}
+
+	return recoveredPubKey.Equal(publicKey), nil
+}
+
+func GetTransactOptsAndSigner(priKey string, chainId *big.Int) (*bind.TransactOpts, DataSignerFunc, error) {
+	privateKey, err := crypto.HexToECDSA(priKey)
+	if err != nil {
+		return nil, nil, err
+	}
+	var txOpts *bind.TransactOpts
+	if chainId != nil {
+		txOpts, err = bind.NewKeyedTransactorWithChainID(privateKey, chainId)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+	signer := func(data []byte) ([]byte, error) {
+		return crypto.Sign(data, privateKey)
+	}
+
+	return txOpts, signer, nil
+}
+
+type DataSignerFunc func([]byte) ([]byte, error)
+
+// GeneratePrivateKeyFromMnemonic generates a private key from a mnemonic phrase
+func GeneratePrivateKeyFromMnemonic(t *testing.T, mnemonic string, index uint) *ecdsa.PrivateKey {
+	wallet, err := hdwallet.NewFromMnemonic(mnemonic)
+	require.NoError(t, err, "Should create wallet from mnemonic")
+
+	path := hdwallet.MustParseDerivationPath(fmt.Sprintf("m/44'/60'/0'/0/%d", index))
+	account, err := wallet.Derive(path, false)
+	require.NoError(t, err, "Should derive account from path")
+
+	privateKey, err := wallet.PrivateKey(account)
+	require.NoError(t, err, "Should get private key from wallet")
+
+	return privateKey
+}
diff --git a/espresso/submitter/multi_worker_queue_espresso_submitter.go b/espresso/submitter/multi_worker_queue_espresso_submitter.go
new file mode 100644
index 00000000000..dd6b14b9063
--- /dev/null
+++ b/espresso/submitter/multi_worker_queue_espresso_submitter.go
@@ -0,0 +1,476 @@
+package submitter
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+	espresso_types "github.com/EspressoSystems/espresso-network/sdks/go/types"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/offchainlabs/nitro/arbutil"
+	"github.com/offchainlabs/nitro/util/stopwaiter"
+)
+
+// MultiWorkerQueueEspressoSubmitter is an implementation of `EspressoSubmitter`
+// that utilizes multiple worker queues to perform Transaction Submission to
+// Espresso, and ensure its inclusion.
+//
+// It approaches the problem by dividing up the task into two separate phases,
+// each of which can be scaled independently as needed.  The two phases are
+// 1. Submit Transaction Phase: This phase is responsible ensuring that a
+// transaction is submitted to Espresso successfully.
+// 2. Transaction Inclusion Phase: This phase is responsible for checking if
+// a transaction is included in Espresso.
+//
+// The approach focuses on two main ideas, split up work into two separate
+// discrete working units, and allow each unit to scale independently, and
+// operate in parallel.
+//
+// By splitting the work into distinct phases, despite them being related,
+// we can ensure that each worker only needs to focus on a single task without
+// distracting itself with the other phase, and complicating the logic.
+//
+// If a Transaction has been successfully submitted to Espresso, but has not
+// been included in Espresso within a specified deadline, it will be demoted
+// and moved back into the Submission phase, where it will be submitted again
+// as if it never was submitted before.
+type MultiWorkerQueueEspressoSubmitter struct {
+	client espresso_client.EspressoClient
+
+	chainID                         uint64
+	resubmissionDeadline            time.Duration
+	numSubmitTransactionWorkers     uint64
+	numTransactionIncludedWorkers   uint64
+	submissionFailureDelayPenalty   time.Duration
+	verificationFailureDelayPenalty time.Duration
+
+	submitTxnsQueue    chan SubmitTransactionJob
+	submitTxnsJobQueue chan chan SubmitTransactionJob
+	submitTxnsResponse chan SubmitTransactionResponse
+
+	transactionIncludedQueue    chan TransactionIncludedJob
+	transactionIncludedJobQueue chan chan TransactionIncludedJob
+	transactionIncludedResponse chan TransactionIncludedResponse
+}
+
+// ErrorFailedToCreateMultiWorkerQueueEspressoSubmitter is an error that is
+// returned when the multi-worker queue espresso submitter fails to be created.
+type ErrorFailedToCreateMultiWorkerQueueEspressoSubmitter struct {
+	Cause error
+}
+
+// Error implements error
+func (e ErrorFailedToCreateMultiWorkerQueueEspressoSubmitter) Error() string {
+	return fmt.Sprintf("failed to create multi-worker queue espresso submitter: %v", e.Cause)
+}
+
+// Unwrap provides the underlying error for builtin errors checking
+func (e ErrorFailedToCreateMultiWorkerQueueEspressoSubmitter) Unwrap() error {
+	return e.Cause
+}
+
+// NewMultiWorkerQueueEspressoSubmitter creates a new WorkerQueues instance
+// with the provided options.
+func NewMultiWorkerQueueEspressoSubmitter(options ...EspressoSubmitterConfigOption) (EspressoSubmitter, error) {
+	config := DefaultEspressoSubmitterConfig
+	applyEspressoSubmitterConfigOptions(&config, options...)
+	if err := ValidateEspressoSubmitterConfig(config); err != nil {
+		return nil, ErrorFailedToCreateMultiWorkerQueueEspressoSubmitter{Cause: err}
+	}
+
+	return &NitroMessageToEspressoTransactionAdapter{
+		db:                           config.Db,
+		chainID:                      config.ChainID,
+		availableTransaction:         make(chan arbutil.MessageIndex, config.MessageIndexQueueSize),
+		messageGetter:                config.MessageGetter,
+		sendingInterval:              config.EspressoTxnSendingInterval,
+		keyManager:                   config.KeyManager,
+		userDataAttestationFile:      config.UserDataAttestationFile,
+		quoteFile:                    config.QuoteFile,
+		espressoMaxTransactionSize:   config.EspressoMaxTransactionSize,
+		initialNitroMessageAvailable: config.InitialNitroMessageAvailable,
+		initialNitroMessageToSubmit:  config.InitialNitroMessageToSubmit,
+		submitter: &MultiWorkerQueueEspressoSubmitter{
+			chainID:                         config.ChainID,
+			resubmissionDeadline:            config.ResubmitEspressoTxDeadline,
+			numSubmitTransactionWorkers:     config.NumberOfSubmitTransactionWorkers,
+			numTransactionIncludedWorkers:   config.NumberOfTransactionIncludedWorkers,
+			client:                          config.EspressoClient,
+			submissionFailureDelayPenalty:   config.SubmissionFailureDelayPenalty,
+			verificationFailureDelayPenalty: config.VerificationFailureDelayPenalty,
+			submitTxnsQueue:                 make(chan SubmitTransactionJob, config.SubmitTransactionsQueueSize),
+			transactionIncludedQueue:        make(chan TransactionIncludedJob, config.TransactionIncludedQueueSize),
+		},
+	}, nil
+}
+
+func (w *MultiWorkerQueueEspressoSubmitter) SubmitTransaction(txn espresso_types.Transaction) {
+	// Let's submit this transaction to the job queue
+	w.submitTxnsQueue <- SubmitTransactionJob{
+		txn: txn,
+	}
+}
+
+// ErrorFailedToLaunchSubmitTransactionQueueWorker is an error that is returned
+// when the submit transaction queue worker fails to launch.
+type ErrorFailedToLaunchSubmitTransactionQueueWorker struct {
+	Cause  error
+	Worker uint64
+}
+
+// Error implements error
+func (e ErrorFailedToLaunchSubmitTransactionQueueWorker) Error() string {
+	return fmt.Sprintf("failed to launch submit transaction queue worker %d: %v", e.Worker, e.Cause)
+}
+
+// Unwrap provides the underlying error for builtin errors checking
+func (e ErrorFailedToLaunchSubmitTransactionQueueWorker) Unwrap() error {
+	return e.Cause
+}
+
+// ErrorFailedToLaunchSubmitTransactionScheduler is an error that is returned
+// when the submit transaction scheduler fails to launch.
+type ErrorFailedToLaunchSubmitTransactionScheduler struct {
+	Cause error
+}
+
+// Error implements error
+func (e ErrorFailedToLaunchSubmitTransactionScheduler) Error() string {
+	return fmt.Sprintf("failed to launch submit transaction scheduler: %v", e.Cause)
+}
+
+// Unwrap provides the underlying error for builtin errors checking
+func (e ErrorFailedToLaunchSubmitTransactionScheduler) Unwrap() error {
+	return e.Cause
+}
+
+// ErrorFailedToLaunchSubmitTransactionResponseHandler is an error that is
+// returned when the submit transaction response handler fails to launch.
+type ErrorFailedToLaunchSubmitTransactionResponseHandler struct {
+	Cause error
+}
+
+// Error implements error
+func (e ErrorFailedToLaunchSubmitTransactionResponseHandler) Error() string {
+	return fmt.Sprintf("failed to launch submit transaction response handler: %v", e.Cause)
+}
+
+// Unwrap provides the underlying error for builtin errors checking
+func (e ErrorFailedToLaunchSubmitTransactionResponseHandler) Unwrap() error {
+	return e.Cause
+}
+
+func (w *MultiWorkerQueueEspressoSubmitter) startSubmitTransactionProcess(sw *stopwaiter.StopWaiter) error {
+	// Launch the workers, scheduler, and responser handler for submit transaction
+	for i := uint64(0); i < w.numSubmitTransactionWorkers; i++ {
+		if err := sw.LaunchThreadSafe(newSubmitTransactionWorker(i, w.client, w.submissionFailureDelayPenalty, w.submitTxnsJobQueue, w.submitTxnsResponse).startWorker); err != nil {
+			return ErrorFailedToLaunchSubmitTransactionQueueWorker{Worker: i, Cause: err}
+		}
+	}
+
+	if err := sw.LaunchThreadSafe(w.submitTransactionScheduler); err != nil {
+		return ErrorFailedToLaunchSubmitTransactionScheduler{Cause: err}
+	}
+
+	if err := sw.LaunchThreadSafe(w.submitTransactionResponseHandler); err != nil {
+		return ErrorFailedToLaunchSubmitTransactionResponseHandler{Cause: err}
+	}
+
+	return nil
+}
+
+// ErrorFailedToLaunchTransactionIncludedQueueWorker is an error that is
+// returned when the transaction included queue worker fails to launch.
+type ErrorFailedToLaunchTransactionIncludedQueueWorker struct {
+	Cause  error
+	Worker uint64
+}
+
+// Error implements error
+func (e ErrorFailedToLaunchTransactionIncludedQueueWorker) Error() string {
+	return fmt.Sprintf("failed to launch transaction included queue worker %d: %v", e.Worker, e.Cause)
+}
+
+// Unwrap provides the underlying error for builtin errors checking
+func (e ErrorFailedToLaunchTransactionIncludedQueueWorker) Unwrap() error {
+	return e.Cause
+}
+
+// ErrorFailedToLaunchTransactionIncludedScheduler is an error that is returned
+// when the transaction included scheduler fails to launch.
+type ErrorFailedToLaunchTransactionIncludedScheduler struct {
+	Cause error
+}
+
+// Error implements error
+func (e ErrorFailedToLaunchTransactionIncludedScheduler) Error() string {
+	return fmt.Sprintf("failed to launch transaction included scheduler: %v", e.Cause)
+}
+
+// Unwrap provides the underlying error for builtin errors checking
+func (e ErrorFailedToLaunchTransactionIncludedScheduler) Unwrap() error {
+	return e.Cause
+}
+
+// ErrorFailedToLaunchTransactionIncludedResponseHandler is an error that is
+// returned when the transaction included response handler fails to launch.
+type ErrorFailedToLaunchTransactionIncludedResponseHandler struct {
+	Cause error
+}
+
+// Error implements error
+func (e ErrorFailedToLaunchTransactionIncludedResponseHandler) Error() string {
+	return fmt.Sprintf("failed to launch transaction included response handler: %v", e.Cause)
+}
+
+// Unwrap provides the underlying error for builtin errors checking
+func (e ErrorFailedToLaunchTransactionIncludedResponseHandler) Unwrap() error {
+	return e.Cause
+}
+
+// startTransactionIncludedProcess launches the transaction included process
+// in a new goroutine using the provided stop waiter.
+func (w *MultiWorkerQueueEspressoSubmitter) startTransactionIncludedProcess(sw *stopwaiter.StopWaiter) error {
+	for i := uint64(0); i < w.numTransactionIncludedWorkers; i++ {
+		if err := sw.LaunchThreadSafe(newTransactionIncludedQueueWorker(i, w.chainID, w.client, w.verificationFailureDelayPenalty, w.transactionIncludedJobQueue, w.transactionIncludedResponse).startWorker); err != nil {
+			return ErrorFailedToLaunchTransactionIncludedQueueWorker{Worker: i, Cause: err}
+		}
+	}
+
+	if err := sw.LaunchThreadSafe(w.transactionIncludedScheduler); err != nil {
+		return ErrorFailedToLaunchTransactionIncludedScheduler{Cause: err}
+	}
+
+	if err := sw.LaunchThreadSafe(w.transactionIncludedResponseHandler); err != nil {
+		return ErrorFailedToLaunchTransactionIncludedResponseHandler{Cause: err}
+	}
+
+	return nil
+}
+
+// ErrorFailedToStart is an error that is returned when the whole worker
+// process fails to start. This can happen if any of the individual components
+// fail to launch.
+type ErrorFailedToStart struct {
+	Cause error
+}
+
+// Error implements error
+func (e ErrorFailedToStart) Error() string {
+	return fmt.Sprintf("failed to start whole worker process: %v", e.Cause)
+}
+
+// Unwrap provides the underlying error for builtin errors checking
+func (e ErrorFailedToStart) Unwrap() error {
+	return e.Cause
+}
+
+// Start implements EspressoSubmitter.
+func (w *MultiWorkerQueueEspressoSubmitter) Start(sw *stopwaiter.StopWaiter) error {
+	w.submitTxnsJobQueue = make(chan chan SubmitTransactionJob, w.numSubmitTransactionWorkers)
+	w.submitTxnsResponse = make(chan SubmitTransactionResponse, 1024)
+
+	w.transactionIncludedJobQueue = make(chan chan TransactionIncludedJob, w.numTransactionIncludedWorkers)
+	w.transactionIncludedResponse = make(chan TransactionIncludedResponse, 1024)
+
+	// Start the submit transaction scheduler, response handlers, and workers
+	if err := w.startSubmitTransactionProcess(sw); err != nil {
+		return ErrorFailedToStart{Cause: err}
+	}
+
+	// Launch the workers, scheduler, and response handler for transaction inclusion
+	if err := w.startTransactionIncludedProcess(sw); err != nil {
+		return ErrorFailedToStart{Cause: err}
+	}
+
+	return nil
+}
+
+// drainSubmitTransactionWorkers closes all the worker channels in the
+// submit transaction job queue, so that the workers can exit gracefully.
+func (w *MultiWorkerQueueEspressoSubmitter) drainSubmitTransactionWorkers() {
+	defer close(w.submitTxnsJobQueue)
+
+	// We need to close the submit transaction job queue, so that the workers
+	// can exit gracefully.
+	for i := uint64(0); i < w.numSubmitTransactionWorkers; i++ {
+		worker, workerOk := <-w.submitTxnsJobQueue
+		if !workerOk {
+			log.Warn("Submit transaction job queue already closed, exiting")
+			// The job queue is closed, so we can exit.
+			return
+		}
+
+		// Close the job queue of the worker, to indicate to it that
+		// there are no more jobs to process
+		close(worker)
+	}
+}
+
+// submitTransactionScheduler is the scheduler for the submit transaction
+// job queue.
+func (w *MultiWorkerQueueEspressoSubmitter) submitTransactionScheduler(ctx context.Context) {
+	defer w.drainSubmitTransactionWorkers()
+
+	for {
+		select {
+		case <-ctx.Done():
+			log.Warn("Submit transaction scheduler exiting")
+			return
+
+		case job, ok := <-w.submitTxnsQueue:
+			// We have a job to process, so let's get a worker, and send the
+			// job to it.
+
+			if !ok {
+				log.Warn("Submit transaction job queue closed, exiting")
+				return
+			}
+
+			worker := <-w.submitTxnsJobQueue
+			worker <- job
+		}
+	}
+}
+
+// submitTransactionResponseHandler is the response handler for the submit
+// transaction job queue.
+//
+// It is responsible for determining the outcome of the performed job, and
+// rescheduling the job upon failure if necessary, or moving the job to the
+// transaction inclusion job queue if the job was successful.
+func (w *MultiWorkerQueueEspressoSubmitter) submitTransactionResponseHandler(ctx context.Context) {
+	for {
+		select {
+		case <-ctx.Done():
+			log.Warn("Submit transaction response handler exiting")
+			return
+
+		case response := <-w.submitTxnsResponse:
+			// We have a response to process, so let's handle it.
+			// This will likely involve updating the state of the
+			// submitter, and possibly notifying other components.
+			if response.err != nil || response.hash == nil {
+				// Handle error case
+				job := response.job
+				log.Warn("Failed to submit transaction to Espresso", "error", response.err, "attempts", job.attempt, "commit", common.Hash(job.txn.Commit()))
+				job.attempt++
+				job.lastAttempt = time.Now()
+				w.submitTxnsQueue <- job
+				continue
+			}
+
+			log.Info("Transaction successfully submitted to Espresso", "hash", response.hash.String(), "commit", common.Hash(response.job.txn.Commit()))
+
+			// The job was successfully submitted, let's move to verification
+			w.transactionIncludedQueue <- TransactionIncludedJob{
+				txnHash:        *response.hash,
+				txn:            response.job.txn,
+				submitSuccess:  time.Now(),
+				submitAttempts: response.job.attempt,
+			}
+		}
+	}
+}
+
+// drainTransactionInclusionWorkers closes all the worker channels in the
+// transaction inclusion job queue, so that the workers can exit gracefully.
+func (w *MultiWorkerQueueEspressoSubmitter) drainTransactionInclusionWorkers() {
+	defer close(w.transactionIncludedJobQueue)
+
+	// We need to close the submit transaction job queue, so that the workers
+	// can exit gracefully.
+	for i := uint64(0); i < w.numTransactionIncludedWorkers; i++ {
+		worker, workerOk := <-w.transactionIncludedJobQueue
+		if !workerOk {
+			// The job queue is closed, so we can exit.
+			log.Warn("Transaction inclusion job queue already closed, exiting")
+			return
+		}
+
+		// Close the job queue of the worker, to indicate to it that
+		// there are no more jobs to process
+		close(worker)
+	}
+}
+
+// transactionIncludedScheduler is the scheduler for the transaction inclusion
+// job queue.
+func (w *MultiWorkerQueueEspressoSubmitter) transactionIncludedScheduler(ctx context.Context) {
+	defer w.drainTransactionInclusionWorkers()
+
+	for {
+		select {
+		case <-ctx.Done():
+			log.Info("Transaction inclusion scheduler exiting")
+			return
+
+		case job, ok := <-w.transactionIncludedQueue:
+			if !ok {
+				// The job queue is closed, so we can exit.
+				log.Info("Transaction inclusion job queue closed, exiting")
+				return
+			}
+			// We have a job to process, so let's get a worker, and send the
+			// job to it.
+
+			worker := <-w.transactionIncludedJobQueue
+			worker <- job
+		}
+	}
+}
+
+// transactionIncludedResponseHandler is the response handler for the
+// transaction inclusion job queue.
+//
+// It is responsible for determining the outcome of the performed job, and
+// rescheduling the job upon failure if necessary.  If a transaction is taking
+// too long to be included in Espresso, it will be resubmitted to the
+// submit transaction job queue for another attempt.
+func (w *MultiWorkerQueueEspressoSubmitter) transactionIncludedResponseHandler(ctx context.Context) {
+	for {
+		select {
+		case <-ctx.Done():
+			log.Info("Transaction inclusion response handler exiting")
+			return
+
+		case response, ok := <-w.transactionIncludedResponse:
+			if !ok {
+				log.Warn("Transaction inclusion response handler channel closed, exiting")
+				return
+			}
+
+			if response.err != nil {
+				if elapsed := time.Since(response.job.submitSuccess); elapsed > w.resubmissionDeadline {
+					log.Warn("Transaction not included in Espresso within the deadline", "hash", response.job.txnHash.String(), "commit", common.Hash(response.job.txn.Commit()), "elapsed", elapsed, "attempts", response.job.attempt)
+					// We have exceeded the resubmission deadline, so we, need
+					// to try and resubmit the transaction.
+					w.submitTxnsQueue <- SubmitTransactionJob{
+						txn:     response.job.txn,
+						attempt: response.job.submitAttempts + 1,
+					}
+					continue
+				}
+
+				log.Info("Transaction not included in Espresso", "hash", response.job.txnHash.String(), "commit", common.Hash(response.job.txn.Commit()), "attempts", response.job.attempt, "error", response.err)
+
+				// Handle error case
+				// Requeue the transaction for another inclusion check attempt
+				job := response.job
+				job.attempt++
+				job.lastAttempt = time.Now()
+				w.transactionIncludedQueue <- job
+				continue
+			}
+
+			// Transaction successfully included, we have no further worker to
+			// do, so we can explicitly drop the job here.
+
+			log.Info("Transaction successfully included in Espresso", "hash", response.job.txnHash.String(), "commit", common.Hash(response.job.txn.Commit()), "attempts", response.job.attempt)
+		}
+	}
+}
diff --git a/espresso/submitter/nitro_message_to_espresso_transaction_adapter.go b/espresso/submitter/nitro_message_to_espresso_transaction_adapter.go
new file mode 100644
index 00000000000..a276c11393e
--- /dev/null
+++ b/espresso/submitter/nitro_message_to_espresso_transaction_adapter.go
@@ -0,0 +1,249 @@
+package submitter
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	espresso_types "github.com/EspressoSystems/espresso-network/sdks/go/types"
+
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rlp"
+
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+	"github.com/offchainlabs/nitro/arbutil"
+	espresso_key_manager "github.com/offchainlabs/nitro/espresso/key-manager"
+	"github.com/offchainlabs/nitro/util"
+	"github.com/offchainlabs/nitro/util/stopwaiter"
+)
+
+// NitroMessageToEspressoTransactionAdapter is an implementation of
+// EspressoSubmitter that adapts Nitro messages to Espresso transactions.
+type NitroMessageToEspressoTransactionAdapter struct {
+	db                           ethdb.Database
+	chainID                      uint64
+	submitter                    *MultiWorkerQueueEspressoSubmitter
+	availableTransaction         chan arbutil.MessageIndex
+	messageGetter                MessageGetter
+	espressoMaxTransactionSize   int64
+	sendingInterval              time.Duration
+	keyManager                   espresso_key_manager.EspressoKeyManagerInterface
+	userDataAttestationFile      string
+	quoteFile                    string
+	initialNitroMessageAvailable arbutil.MessageIndex
+	initialNitroMessageToSubmit  arbutil.MessageIndex
+}
+
+// Compile time check to ensure WorkerQueues implements EspressoSubmitter
+var _ EspressoSubmitter = &NitroMessageToEspressoTransactionAdapter{}
+
+// fetchMessageForPos fetches the message at the given position from the
+// message getter.
+func (n *NitroMessageToEspressoTransactionAdapter) fetchMessageForPos(pos arbutil.MessageIndex) ([]byte, error) {
+	msg, err := n.messageGetter.GetMessage(pos)
+	if err != nil {
+		return nil, err
+	}
+	if pos > 1 {
+		prevMsg, err := n.messageGetter.GetMessage(pos - 1)
+		if err != nil {
+			return nil, err
+		}
+		if prevMsg.DelayedMessagesRead+1 == msg.DelayedMessagesRead {
+			// This message is a delayed message, and it should not be included
+			// in the hotshot payload. The caff node is supposed to fetch the delayed message
+			// from L1.
+			// setting `msg.Message` to `nil` will cause a rlp decode/encode error
+			// so we set `L2msg` to an empty byte slice instead
+			msg.Message.L2msg = []byte{}
+		}
+	}
+	b, err := rlp.EncodeToBytes(msg)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
+
+// bundleTransactions builds an Espresso Transaction attempting to bundle as
+// many messages as possible into a single transaction.
+func (n *NitroMessageToEspressoTransactionAdapter) bundleTransactions(startPos, endPos arbutil.MessageIndex) (arbutil.MessageIndex, error) {
+	i := startPos
+	pendingTxnsPos := util.CreateSliceOfIntegerForRangeInclusive(startPos, endPos)
+	for i <= endPos {
+		payload, msgCnt := arbutil.BuildRawHotShotPayload(pendingTxnsPos, n.fetchMessageForPos, n.espressoMaxTransactionSize)
+		i += util.ConvertToUint64WithFallback[int, arbutil.MessageIndex](msgCnt, 1)
+		pendingTxnsPos = pendingTxnsPos[msgCnt:]
+
+		if msgCnt == 0 {
+			return startPos, ErrorBundledHotShotTransactionContainsNoMessages{}
+		}
+
+		payload, err := arbutil.SignHotShotPayload(payload, n.keyManager.SignPayload)
+		if err != nil {
+			return startPos, ErrorFailedToSignDataForHotShotPayload{Cause: err}
+		}
+
+		txn := espresso_types.Transaction{
+			Namespace: n.chainID,
+			Payload:   payload,
+		}
+
+		n.submitter.SubmitTransaction(txn)
+	}
+
+	return endPos, nil
+}
+
+// bundleTransactionsProcess is a method that is meant to be run in a
+// goroutine.
+//
+// It keeps track of the available positions of the transactions, as updated
+// and reported by the NotifyNewPendingMessages method.
+//
+// Once per sending interval, it will attempt to bundle all of the available
+// messages into multiple Espresso transactions, and submit them to the
+// submit transaction job queue.
+func (n *NitroMessageToEspressoTransactionAdapter) bundleTransactionsProcess(ctx context.Context) {
+	availablePos, submittedPos := n.initialNitroMessageAvailable, n.initialNitroMessageToSubmit
+	ticker := time.NewTicker(n.sendingInterval)
+
+	for {
+		select {
+		case <-ctx.Done():
+			log.Warn("Bundle transactions process exiting, due to context done", "error", ctx.Err())
+			return
+
+		case pos, ok := <-n.availableTransaction:
+			if !ok {
+				log.Warn("Available transaction channel closed, exiting bundle transactions process")
+				// The channel is closed, so we can exit
+				return
+			}
+
+			if availablePos < pos {
+				// We have a new available position, let's update it
+				availablePos = pos
+			}
+
+		case <-ticker.C:
+			// We have a ticker event, let's check if we have any pending transactions
+			if availablePos == submittedPos {
+				// No pending transactions, so we can skip this iteration
+				continue
+			}
+
+			// Let's bundle our transactions
+			nextPos, err := n.bundleTransactions(submittedPos, availablePos)
+			if err != nil {
+				log.Error("Failed to bundle transactions", "startPos", submittedPos, "endPos", availablePos, "error", err)
+				// We can continue to the next iteration, as we will try again later
+				continue
+			}
+
+			submittedPos = nextPos
+		}
+	}
+}
+
+// startBundleTransactionsProcess launches the bundle transactions process
+// in a new goroutine using the provided stop waiter.
+func (n *NitroMessageToEspressoTransactionAdapter) startBundleTransactionsProcess(sw *stopwaiter.StopWaiter) error {
+	if err := sw.LaunchThreadSafe(n.bundleTransactionsProcess); err != nil {
+		return ErrorFailedToLaunchBundleTransactionsProcess{Cause: err}
+	}
+	return nil
+}
+
+// Start implements EspressoSubmitter.
+//
+// This schedules the bundle transactions process to run in a new goroutine,
+func (n *NitroMessageToEspressoTransactionAdapter) Start(sw *stopwaiter.StopWaiter) error {
+	// start the bundle transactions process in a new goroutine
+	if err := n.startBundleTransactionsProcess(sw); err != nil {
+		return ErrorFailedToStart{Cause: err}
+	}
+
+	if err := n.submitter.Start(sw); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// NotifyNewPendingMessages is a method that is called when new pending messages
+// are available to be processed.
+func (n *NitroMessageToEspressoTransactionAdapter) NotifyNewPendingMessages(pos arbutil.MessageIndex, messages []arbostypes.MessageWithMetadataAndBlockInfo) error {
+	select {
+	default:
+		return ErrorWorkerQueuesAreFull{Pos: pos}
+
+	case n.availableTransaction <- pos:
+		return nil
+	}
+}
+
+// GetKeyManager returns the key manager used by this Espresso submitter.
+func (n *NitroMessageToEspressoTransactionAdapter) GetKeyManager() espresso_key_manager.EspressoKeyManagerInterface {
+	return n.keyManager
+}
+
+func (n *NitroMessageToEspressoTransactionAdapter) EnqueuePendingTransaction(pos []arbutil.MessageIndex) error {
+	return nil
+}
+
+// ErrorWorkerQueuesAreFull is an error that is returned when the worker queues
+// are full, and cannot accept new pending messages.
+type ErrorWorkerQueuesAreFull struct {
+	Pos arbutil.MessageIndex
+}
+
+// Error implements error
+func (e ErrorWorkerQueuesAreFull) Error() string {
+	return fmt.Sprintf("worker queues are full, cannot accept new pending messages at position %d", e.Pos)
+}
+
+// ErrorBundledHotShotTransactionContainsNoMessages is an error that is returned
+// when a bundled hotshot transaction contains no messages. This can happen if
+// a large message has exceeded the size limit or failed to get a message from
+// storage.
+type ErrorBundledHotShotTransactionContainsNoMessages struct{}
+
+// Error implements error
+func (e ErrorBundledHotShotTransactionContainsNoMessages) Error() string {
+	return "failed to build the hotshot transaction: the result contained no messages. This can happen if a large message has exceeded the size limit or failed to get a message from storage."
+}
+
+// ErrorFailedToSignDataForHotShotPayload is an error that is returned
+// when the signing of the data for the hotshot payload fails. This can happen
+// if the key manager fails to sign the data, or if the data is malformed.
+type ErrorFailedToSignDataForHotShotPayload struct {
+	Cause error
+}
+
+// Error implements error
+func (e ErrorFailedToSignDataForHotShotPayload) Error() string {
+	return fmt.Sprintf("failed to sign the data for hotshot payload: %v", e.Cause)
+}
+
+// Unwrap provides the underlying error for builtin errors checking
+func (e ErrorFailedToSignDataForHotShotPayload) Unwrap() error {
+	return e.Cause
+}
+
+// ErrorFailedToLaunchBundleTransactionsProcess is an error that is returned
+// when the bundle transactions process fails to launch.
+type ErrorFailedToLaunchBundleTransactionsProcess struct {
+	Cause error
+}
+
+// Error implements error
+func (e ErrorFailedToLaunchBundleTransactionsProcess) Error() string {
+	return fmt.Sprintf("failed to launch bundle transactions process: %v", e.Cause)
+}
+
+// Unwrap provides the underlying error for builtin errors checking
+func (e ErrorFailedToLaunchBundleTransactionsProcess) Unwrap() error {
+	return e.Cause
+}
diff --git a/espresso/submitter/polling_espresso_submitter.go b/espresso/submitter/polling_espresso_submitter.go
new file mode 100644
index 00000000000..bb74c983446
--- /dev/null
+++ b/espresso/submitter/polling_espresso_submitter.go
@@ -0,0 +1,647 @@
+package submitter
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math/big"
+	"sync"
+	"time"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+	tagged_base64 "github.com/EspressoSystems/espresso-network/sdks/go/tagged-base64"
+	espresso_types "github.com/EspressoSystems/espresso-network/sdks/go/types"
+	"github.com/ccoveille/go-safecast"
+
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rlp"
+
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+	"github.com/offchainlabs/nitro/arbutil"
+	espresso_key_manager "github.com/offchainlabs/nitro/espresso/key-manager"
+	"github.com/offchainlabs/nitro/util"
+	"github.com/offchainlabs/nitro/util/stopwaiter"
+)
+
+var (
+	// Schema extensions for Espresso Tracking
+	espressoSubmittedTxns        []byte = []byte("_espressoSubmittedTxns")  // contains the hash and pos of the submitted transactions
+	espressoPendingTxnsPositions []byte = []byte("_espressoPendingTxnsPos") // contains the index of the pending txns that need to be submitted to espresso
+)
+
+// PollingEspressoSubmitter is a struct that implements the [EspressoSubmitter]
+// interface and provides methods to submit transactions to Espresso,
+// manage pending.
+//
+// It is the is the initial implementation of the [EspressoSubmitter] interface
+// with the underlying implementation taken from the [TransactionSubmitter]
+// implementation as of 2025-07-23.
+//
+// The underlying implementation separates the logic of submitting and ensuring
+// the existing of Transactions to Espresso via three separate polling run
+// loops that performs their individual tasks in a sequential manner.
+//
+// The Three Run Loops are separately responsible for:
+// - Building Transactions and submitting them to Espresso
+// - Checking for finality of submitted Transactions to remove them from the
+// pending queue
+// - Resubmitting Transactions that have not been finalized within a
+// specified deadline.
+type PollingEspressoSubmitter struct {
+	espressoPendingTxnPosMutex sync.Mutex
+	espressoSubmittedTxnsMutex sync.Mutex
+
+	db                 ethdb.Database
+	messageGetter      MessageGetter
+	espressoClient     espresso_client.EspressoClient
+	espressoKeyManager espresso_key_manager.EspressoKeyManagerInterface
+
+	canSubmit func(ctx context.Context) (bool, error)
+
+	chainID                               uint64
+	espressoTxnsMonitoringInterval        time.Duration
+	espressoTxnsResubmissionInterval      time.Duration
+	espressoMaxTransactionSize            int64
+	resubmitEspressoTxDeadline            time.Duration
+	lastSubmitFailureAt                   *time.Time
+	InitialFinalizedSequencerMessageCount *big.Int
+}
+
+var _ EspressoSubmitter = &PollingEspressoSubmitter{}
+
+// NewPollingEspressoSubmitter is a constructor function that creates a new
+// [PollingEspressoSubmitter] instance with the provided configuration options.
+func NewPollingEspressoSubmitter(options ...EspressoSubmitterConfigOption) (EspressoSubmitter, error) {
+	config := DefaultEspressoSubmitterConfig
+
+	for _, option := range options {
+		option(&config)
+	}
+
+	// Validate the config, to ensure we have everything we need to move
+	// forward
+	if err := ValidateEspressoSubmitterConfig(config); err != nil {
+		return nil, fmt.Errorf("invalid espresso submitter config: %w", err)
+	}
+
+	return &PollingEspressoSubmitter{
+		db:                 config.Db,
+		messageGetter:      config.MessageGetter,
+		espressoClient:     config.EspressoClient,
+		espressoKeyManager: config.KeyManager,
+
+		chainID:                          config.ChainID,
+		espressoTxnsResubmissionInterval: config.EspressoTxnsResubmissionInterval,
+		espressoTxnsMonitoringInterval:   config.EspressoTxnsMonitoringInterval,
+		espressoMaxTransactionSize:       config.EspressoMaxTransactionSize,
+		resubmitEspressoTxDeadline:       config.ResubmitEspressoTxDeadline,
+
+		InitialFinalizedSequencerMessageCount: config.InitialFinalizedSequencerMessageCount,
+		canSubmit:                             config.CanSubmit,
+	}, nil
+}
+
+func (s *PollingEspressoSubmitter) EnqueuePendingTransaction(pos []arbutil.MessageIndex) error {
+	// Store the pos in the database to be used later to submit the message
+	// to hotshot for finalization.
+	err := s.SubmitEspressoTransactionPos(pos)
+	if err != nil {
+		log.Error("failed to submit espresso transaction pos", "pos", pos, "err", err)
+		return err
+	}
+	return nil
+}
+
+// Check if the latest submitted transaction has been finalized on L1 and verify it.
+// Return a bool indicating whether a new transaction can be submitted to HotShot
+func (s *PollingEspressoSubmitter) checkSubmittedTransactionForFinality(ctx context.Context) error {
+	s.espressoSubmittedTxnsMutex.Lock()
+	defer s.espressoSubmittedTxnsMutex.Unlock()
+
+	submittedTxns, err := s.getEspressoSubmittedTxns()
+	if err != nil {
+		return fmt.Errorf("submitted transactions not found: %w", err)
+	}
+	if len(submittedTxns) == 0 {
+		return nil // no submitted transaction, treated as successful
+	}
+
+	batch := s.db.NewBatch()
+	newSubmittedTxns := []arbutil.SubmittedEspressoTx{}
+	blockHeights := []uint64{}
+	posArray := []int{}
+	for i, submittedTx := range submittedTxns {
+		hash := submittedTx.Hash
+		submittedTxHash, err := tagged_base64.Parse(hash)
+		if err != nil || submittedTxHash == nil {
+			return fmt.Errorf("invalid hotshot tx hash, failed to parse hash %s: %w", hash, err)
+		}
+
+		blockHeight, err := s.checkEspressoQueryNodesForTransaction(ctx, submittedTxHash)
+		if err != nil {
+			resubmittedTxn, err := s.resubmitTransactionIfPastDelay(ctx, submittedTx)
+			if err != nil {
+				log.Error("failed to resubmit transaction", "err", err)
+			}
+			if resubmittedTxn != nil {
+				newSubmittedTxns = append(newSubmittedTxns, *resubmittedTxn)
+			} else {
+				newSubmittedTxns = append(newSubmittedTxns, submittedTx)
+			}
+			continue
+		}
+		log.Info("transaction checked", "hash", hash, "data", blockHeight)
+
+		blockHeights = append(blockHeights, blockHeight)
+		posArray = append(posArray, i)
+	}
+
+	for i, height := range blockHeights {
+		submittedTx := submittedTxns[posArray[i]]
+
+		resp, err := s.espressoClient.FetchTransactionsInBlock(ctx, height, s.chainID)
+		if err != nil {
+			log.Warn("Failed to fetch transactions in block referenced in fetch transaction by hash", "height", height, "error", err)
+			// Keep our submitted transaction in the list so we keep checking it
+			newSubmittedTxns = append(newSubmittedTxns, submittedTx)
+			continue
+		}
+
+		validated := arbutil.ValidateIfPayloadIsInBlock(submittedTx.Payload, resp.Transactions)
+		if !validated {
+			// This may seem redundant as we have a resubmission loop, but hitting this code path means that we were able to find the submitted tx hash across a quorom of
+			// the query nodes, and got a result for what block it should be in. However, we were unable to validate that the payload was in the block.
+			log.Warn("Transaction payload not found in block,The txn should be re-submitted", "height", height, "tx", submittedTx.Hash)
+			resubmittedTxn, err := s.resubmitTransaction(ctx, submittedTx)
+			if err != nil || resubmittedTxn == nil {
+				// resubmittedTxn should never be nil, but we check it just in case
+				log.Error("failed to resubmit transaction", "err", err)
+				// Let's not lose track of our submitted transaction
+				newSubmittedTxns = append(newSubmittedTxns, submittedTx)
+				continue
+			}
+			newSubmittedTxns = append(newSubmittedTxns, *resubmittedTxn)
+			continue
+		}
+
+	}
+
+	// this will be remmoved in other PRs
+	err = s.setEspressoSubmittedTxns(batch, newSubmittedTxns)
+	if err != nil {
+		return fmt.Errorf("failed to set espresso submitted txns: %w", err)
+	}
+
+	if err = batch.Write(); err != nil {
+		return fmt.Errorf("failed to write to db: %w", err)
+	}
+
+	return nil
+}
+
+func (s *PollingEspressoSubmitter) checkEspressoQueryNodesForTransaction(ctx context.Context, hash *tagged_base64.TaggedBase64) (uint64, error) {
+	payload, err := s.espressoClient.FetchExplorerTransactionByHash(ctx, hash)
+	if err != nil {
+		return 0, fmt.Errorf("failed to fetch transaction from espresso: %w", err)
+	}
+
+	return payload.TransactionsDetails.ExplorerDetails.BlockHeight, nil
+}
+
+func (s *PollingEspressoSubmitter) resubmitTransaction(ctx context.Context, submittedTx arbutil.SubmittedEspressoTx) (*arbutil.SubmittedEspressoTx, error) {
+	submittedAt := time.Now()
+	hash, err := s.espressoClient.SubmitTransaction(ctx, espresso_types.Transaction{
+		Payload:   submittedTx.Payload,
+		Namespace: s.chainID,
+	})
+	if err != nil {
+		return nil, err
+	}
+	submittedTx.Hash = hash.String()
+	submittedTx.SubmittedAt = submittedAt
+	return &submittedTx, nil
+}
+
+func (s *PollingEspressoSubmitter) resubmitTransactionIfPastDelay(ctx context.Context, submittedTx arbutil.SubmittedEspressoTx) (*arbutil.SubmittedEspressoTx, error) {
+	timeSinceSubmission := time.Since(submittedTx.SubmittedAt)
+	if timeSinceSubmission < s.resubmitEspressoTxDeadline {
+		return nil, nil
+	}
+	return s.resubmitTransaction(ctx, submittedTx)
+}
+
+func (s *PollingEspressoSubmitter) getEspressoSubmittedTxns() ([]arbutil.SubmittedEspressoTx, error) {
+	posBytes, err := s.db.Get(espressoSubmittedTxns)
+	if err != nil {
+		if rawdb.IsDbErrNotFound(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	var tx []arbutil.SubmittedEspressoTx
+	err = rlp.DecodeBytes(posBytes, &tx)
+	if err != nil {
+		return nil, err
+	}
+	return tx, nil
+}
+
+func (s *PollingEspressoSubmitter) getEspressoPendingTxnsPos() ([]arbutil.MessageIndex, error) {
+	pendingTxnsBytes, err := s.db.Get(espressoPendingTxnsPositions)
+	if err != nil {
+		if rawdb.IsDbErrNotFound(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	var pendingTxnsPos []arbutil.MessageIndex
+	err = rlp.DecodeBytes(pendingTxnsBytes, &pendingTxnsPos)
+	if err != nil {
+		return nil, err
+	}
+	return pendingTxnsPos, nil
+}
+
+func (s *PollingEspressoSubmitter) setEspressoSubmittedTxns(batch ethdb.KeyValueWriter, txns []arbutil.SubmittedEspressoTx) error {
+	// if pos is nil, delete the key
+	if txns == nil {
+		err := batch.Delete(espressoSubmittedTxns)
+		return err
+	}
+
+	bytes, err := rlp.EncodeToBytes(txns)
+	if err != nil {
+		return err
+	}
+	err = batch.Put(espressoSubmittedTxns, bytes)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *PollingEspressoSubmitter) setEspressoPendingTxnsPos(batch ethdb.KeyValueWriter, pos []arbutil.MessageIndex) error {
+	if pos == nil {
+		err := batch.Delete(espressoPendingTxnsPositions)
+		return err
+	}
+
+	posBytes, err := rlp.EncodeToBytes(pos)
+	if err != nil {
+		return err
+	}
+	err = batch.Put(espressoPendingTxnsPositions, posBytes)
+	if err != nil {
+		return err
+
+	}
+	return nil
+}
+
+// Append a position to the pending queue. Please ensure this position is valid beforehand.
+func (s *PollingEspressoSubmitter) SubmitEspressoTransactionPos(pos []arbutil.MessageIndex) error {
+	s.espressoPendingTxnPosMutex.Lock()
+	defer s.espressoPendingTxnPosMutex.Unlock()
+
+	batch := s.db.NewBatch()
+	pendingTxnsPos, err := s.getEspressoPendingTxnsPos()
+	if err != nil {
+		return err
+	}
+
+	if pendingTxnsPos == nil {
+		// if the key doesn't exist, create a new array with the pos
+		pendingTxnsPos = pos
+	} else {
+		pendingTxnsPos = append(pendingTxnsPos, pos...)
+	}
+	err = s.setEspressoPendingTxnsPos(batch, pendingTxnsPos)
+	if err != nil {
+		log.Error("failed to set the pending txns", "err", err)
+		return err
+	}
+
+	err = batch.Write()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *PollingEspressoSubmitter) ResubmitEspressoTransactions(ctx context.Context, tx arbutil.SubmittedEspressoTx) (*tagged_base64.TaggedBase64, error) {
+	txHash, err := s.espressoClient.SubmitTransaction(ctx, espresso_types.Transaction{
+		Payload:   tx.Payload,
+		Namespace: s.chainID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return txHash, nil
+}
+
+func (s *PollingEspressoSubmitter) submitEspressoTransactions(ctx context.Context) error {
+	s.espressoPendingTxnPosMutex.Lock()
+	defer s.espressoPendingTxnPosMutex.Unlock()
+
+	pendingTxnsPos, err := s.getEspressoPendingTxnsPos()
+	if err != nil {
+		return err
+	}
+
+	if len(pendingTxnsPos) == 0 {
+		return nil
+	}
+
+	fetcher := func(pos arbutil.MessageIndex) ([]byte, error) {
+		msg, err := s.messageGetter.GetMessage(pos)
+		if err != nil {
+			return nil, err
+		}
+		if pos > 1 {
+			prevMsg, err := s.messageGetter.GetMessage(pos - 1)
+			if err != nil {
+				return nil, err
+			}
+			if prevMsg.DelayedMessagesRead+1 == msg.DelayedMessagesRead {
+				// This message is a delayed message, and it should not be included
+				// in the hotshot payload. The caff node is supposed to fetch the delayed message
+				// from L1.
+				// setting `msg.Message` to `nil` will cause a rlp decode/encode error
+				// so we set `L2msg` to an empty byte slice instead
+				msg.Message.L2msg = []byte{}
+			}
+		}
+		b, err := rlp.EncodeToBytes(msg)
+		if err != nil {
+			return nil, err
+		}
+		return b, nil
+	}
+	payload, msgCnt := arbutil.BuildRawHotShotPayload(pendingTxnsPos, fetcher, s.espressoMaxTransactionSize)
+	batch := s.db.NewBatch()
+	submittedPos := pendingTxnsPos[:msgCnt]
+	pendingTxnsPos = pendingTxnsPos[msgCnt:]
+
+	err = s.setEspressoPendingTxnsPos(batch, pendingTxnsPos)
+
+	if err != nil {
+		return fmt.Errorf("failed to set the pending txn list in the db batch: %w", err)
+	}
+	if msgCnt == 0 {
+		return fmt.Errorf("failed to build the hotshot transaction: a large message has exceeded the size limit or failed to get a message from storage")
+	}
+
+	payload, err = arbutil.SignHotShotPayload(payload, s.espressoKeyManager.SignPayload)
+	if err != nil {
+		return fmt.Errorf("failed to sign the hotshot payload %w", err)
+	}
+
+	log.Info("submitting transaction to hotshot for finalization")
+
+	submittedAt := time.Now()
+	// Note: same key should not be used for two namespaces for this to work
+	hash, err := s.espressoClient.SubmitTransaction(ctx, espresso_types.Transaction{
+		Payload:   payload,
+		Namespace: s.chainID,
+	})
+
+	if err != nil {
+		return fmt.Errorf("failed to submit transaction to espresso: %w", err)
+	}
+
+	s.espressoSubmittedTxnsMutex.Lock()
+	defer s.espressoSubmittedTxnsMutex.Unlock()
+
+	submittedTxns, err := s.getEspressoSubmittedTxns()
+	if err != nil {
+		return fmt.Errorf("failed to get the submitted txns: %w", err)
+	}
+	tx := arbutil.SubmittedEspressoTx{
+		Hash:        hash.String(),
+		Pos:         submittedPos,
+		Payload:     payload,
+		SubmittedAt: submittedAt,
+	}
+	if submittedTxns == nil {
+		submittedTxns = []arbutil.SubmittedEspressoTx{tx}
+	} else {
+		submittedTxns = append(submittedTxns, tx)
+	}
+
+	if err = s.setEspressoSubmittedTxns(batch, submittedTxns); err != nil {
+		return fmt.Errorf("failed to set espresso submitted txns: %w", err)
+	}
+
+	err = batch.Write()
+	if err != nil {
+		return fmt.Errorf("failed to write to db: %w", err)
+	}
+	return nil
+}
+
+var ErrEspressoValidation = errors.New("failed to check espresso validation")
+var ErrEspressoFetchTransaction = errors.New("failed to fetch the espresso transaction")
+
+var espressoMerkleProofEphemeralErrorHandler = util.NewEphemeralErrorHandler(80*time.Minute, ErrEspressoValidation.Error(), 15*time.Minute)
+var espressoTransactionEphemeralErrorHandler = util.NewEphemeralErrorHandler(3*time.Minute, ErrEspressoFetchTransaction.Error(), 15*time.Minute)
+
+func getLogLevel(err error) func(string, ...interface{}) {
+	logLevel := log.Error
+	logLevel = espressoMerkleProofEphemeralErrorHandler.LogLevel(err, logLevel)
+	logLevel = espressoTransactionEphemeralErrorHandler.LogLevel(err, logLevel)
+	return logLevel
+}
+
+// pollSubmittedTransactionForFinality checks if the submitted transaction has
+// been finalized by Espresso  and verifies it.
+func (s *PollingEspressoSubmitter) pollSubmittedTransactionForFinality(ctx context.Context, ignored struct{}) time.Duration {
+	retryRate := s.espressoTxnsMonitoringInterval * 2
+	err := s.checkSubmittedTransactionForFinality(ctx)
+	if err != nil {
+		if ctx.Err() != nil {
+			return s.espressoTxnsMonitoringInterval
+		}
+		logLevel := getLogLevel(err)
+		logLevel("error polling finality, will retry", "err", err)
+		return retryRate
+	}
+	espressoMerkleProofEphemeralErrorHandler.Reset()
+	return s.espressoTxnsMonitoringInterval
+}
+
+// submitTransactionsToEspresso submits the transactions to espresso if the
+// escape hatch is not enabled
+func (s *PollingEspressoSubmitter) submitTransactionsToEspresso(ctx context.Context, ignored struct{}) time.Duration {
+	// When encountering an error during the initial attempt at submitting a transaction, double the amount of our polling interval and try again.
+	retryRate := s.espressoTxnsMonitoringInterval * 2
+
+	ok, err := s.canSubmit(ctx)
+	if err != nil {
+		return s.espressoTxnsMonitoringInterval
+	}
+
+	if !ok {
+		return retryRate
+	}
+	shouldSubmit := s.shouldSubmitEspressoTransaction(nil)
+	// Only submit the transaction if escape hatch is not enabled
+	if shouldSubmit {
+		err := s.submitEspressoTransactions(ctx)
+
+		if err != nil {
+			log.Error("failed to submit espresso transactions", "err", err)
+			return retryRate
+		}
+	}
+	return s.espressoTxnsMonitoringInterval
+}
+
+func (s *PollingEspressoSubmitter) pollToResubmitEspressoTransactions(ctx context.Context, ignored struct{}) time.Duration {
+	retryRate := s.espressoTxnsResubmissionInterval * 2
+	submittedTxns, err := s.getEspressoSubmittedTxns()
+	if err != nil {
+		log.Warn("resubmitting espresso transactions failed: unable to get submitted transactions, will retry", "err", err)
+		return retryRate
+	}
+
+	shouldResubmit := s.shouldResubmitEspressoTransactions(ctx, submittedTxns)
+	if shouldResubmit {
+		for _, tx := range submittedTxns {
+			log.Info("Resubmitting tx to Espresso", "tx", tx.Hash)
+			txHash, err := s.ResubmitEspressoTransactions(ctx, tx)
+			if err != nil {
+				log.Warn("failed to resubmit espresso transactions", "err", err)
+				return retryRate
+			}
+			log.Info("trying to resubmit transaction succeeded", "hash", txHash.String())
+		}
+		// Reset the last submit failure time because we successfully resubmitted the transactions
+		s.lastSubmitFailureAt = nil
+	}
+	return s.espressoTxnsResubmissionInterval
+}
+
+// shouldSubmitEspressoTransaction is a method that checks the conditions under
+// which we are able to submit transactions to Espresso.  If these conditions
+// are not met, we will not submit the transaction to Espresso.
+//
+// The necessary conditions are:
+//   - The Espresso Client must be set
+//   - The given `pos` parameter must be after our recorded finalized sequencer
+//     message count
+//
+// NOTE: This method does not acquire any locks, so its state may change
+// when running concurrently with other methods.
+func (s *PollingEspressoSubmitter) shouldSubmitEspressoTransaction(pos *uint64) bool {
+	if s.espressoClient == nil {
+		return false
+	}
+	if pos != nil {
+		if *pos < s.InitialFinalizedSequencerMessageCount.Uint64() {
+			log.Warn("not submitting transaction to espresso due to it being finalized", "pos", *pos, "sequencerMessageCount", s.InitialFinalizedSequencerMessageCount)
+			return false
+		}
+	}
+
+	return true
+}
+
+func (s *PollingEspressoSubmitter) shouldResubmitEspressoTransactions(ctx context.Context, submittedTxns []arbutil.SubmittedEspressoTx) bool {
+	if len(submittedTxns) == 0 {
+		// If no submitted transactions, we dont need to resubmit
+		return false
+	}
+	firstSubmitted := submittedTxns[0]
+	hash := firstSubmitted.Hash
+
+	submittedTxHash, err := tagged_base64.Parse(hash)
+	if err != nil || submittedTxHash == nil {
+		log.Error("invalid hotshot tx hash, failed to parse hash", "hash", hash, "err", err)
+		return false
+	}
+
+	_, err = s.espressoClient.FetchExplorerTransactionByHash(ctx, submittedTxHash)
+	if err == nil {
+		// if we are able to fetch the transaction, we dont need to resubmit
+		return false
+	}
+
+	if s.lastSubmitFailureAt == nil {
+		now := time.Now()
+		s.lastSubmitFailureAt = &now
+		log.Warn("will wait for resubmission deadline before resubmitting transaction, will retry again", "hash", submittedTxHash.String(), "err", err)
+		return false
+	}
+	duration := time.Since(*s.lastSubmitFailureAt)
+	if duration < s.resubmitEspressoTxDeadline {
+		log.Warn("resubmission deadline not reached, will retry again", "hash", submittedTxHash.String(), "err", err)
+		return false
+	}
+
+	return true
+}
+
+func (s *PollingEspressoSubmitter) Start(sw *stopwaiter.StopWaiter) error {
+	if s.espressoClient != nil {
+		err := stopwaiter.CallIterativelyWith[struct{}](sw, s.pollSubmittedTransactionForFinality, nil)
+		if err != nil {
+			return err
+		}
+		err = stopwaiter.CallIterativelyWith[struct{}](sw, s.submitTransactionsToEspresso, nil)
+		if err != nil {
+			return err
+		}
+		err = stopwaiter.CallIterativelyWith[struct{}](sw, s.pollToResubmitEspressoTransactions, nil)
+		if err != nil {
+			return err
+		}
+	} else {
+		log.Warn("espresso client not set, skipping espresso verification")
+	}
+
+	return nil
+}
+
+func (s *PollingEspressoSubmitter) NotifyNewPendingMessages(firstMsgIdx arbutil.MessageIndex, messages []arbostypes.MessageWithMetadataAndBlockInfo) error {
+	//  Only submit the transaction if escape hatch is not enabled
+	var messagesToEnqueue []arbutil.MessageIndex
+	for i := range messages {
+		idx, err := safecast.ToUint64(i)
+		if err != nil {
+			return err
+		}
+		indexToSubmit := (firstMsgIdx + arbutil.MessageIndex(idx))
+
+		// convert to uint64
+		indexToSubmitUint64, err := safecast.ToUint64(indexToSubmit)
+		if err != nil {
+			return err
+		}
+		if s.shouldSubmitEspressoTransaction(&indexToSubmitUint64) {
+			log.Info("adding transaction to list of pending tx's to submit to Espresso", "pos", indexToSubmit)
+			messagesToEnqueue = append(messagesToEnqueue, indexToSubmit)
+		}
+	}
+
+	if len(messagesToEnqueue) > 0 {
+		err := s.EnqueuePendingTransaction(messagesToEnqueue)
+		if err != nil {
+			log.Error("unable to enqueue a transaction to the pending list to be submitted to espresso.", "err", err, "messages", messagesToEnqueue)
+			return err
+		}
+		startIdx := messagesToEnqueue[0]
+		endIdx := messagesToEnqueue[len(messagesToEnqueue)-1]
+		log.Info("Successfully enqueued range of transactions from startIdx to endIdx", "startIdx", startIdx, "endIdx", endIdx)
+	}
+
+	return nil
+}
+
+func (t *PollingEspressoSubmitter) GetKeyManager() espresso_key_manager.EspressoKeyManagerInterface {
+	return t.espressoKeyManager
+}
diff --git a/espresso/submitter/submit_transaction_worker.go b/espresso/submitter/submit_transaction_worker.go
new file mode 100644
index 00000000000..d62c0f182b7
--- /dev/null
+++ b/espresso/submitter/submit_transaction_worker.go
@@ -0,0 +1,147 @@
+package submitter
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+	tagged_base64 "github.com/EspressoSystems/espresso-network/sdks/go/tagged-base64"
+	espresso_types "github.com/EspressoSystems/espresso-network/sdks/go/types"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/offchainlabs/nitro/util"
+)
+
+// SubmitTransactionJob represents a job to submit a transaction to Espresso.
+type SubmitTransactionJob struct {
+	txn         espresso_types.Transaction
+	attempt     uint
+	lastAttempt time.Time
+}
+
+// SubmitTransactionResponse represents a response / result of a performed
+// SubmitTransactionJob task
+type SubmitTransactionResponse struct {
+	job  SubmitTransactionJob
+	hash *espresso_types.TaggedBase64
+	err  error
+}
+
+// submitTransactionWorker is a worker that processes SubmitTransactionJob
+// tasks.
+//
+// It is **only** responsible for submitting transactions to Espresso, and
+// returning the response back to be handled.
+type submitTransactionWorker struct {
+	id                 uint64
+	client             espresso_client.EspressoClient
+	delayPenalty       time.Duration
+	submitTxnsJobQueue chan<- chan SubmitTransactionJob
+	submitTxnsResponse chan<- SubmitTransactionResponse
+}
+
+// newSubmitTransactionWorker creates a new submit transaction worker with the
+// given ID, client, job queue, and response channel.
+func newSubmitTransactionWorker(
+	id uint64, client espresso_client.EspressoClient,
+	delayPenalty time.Duration,
+	submitTxnsJobQueue chan<- chan SubmitTransactionJob,
+	submitTxnsResponse chan<- SubmitTransactionResponse,
+) *submitTransactionWorker {
+	return &submitTransactionWorker{
+		id:                 id,
+		client:             client,
+		delayPenalty:       delayPenalty,
+		submitTxnsJobQueue: submitTxnsJobQueue,
+		submitTxnsResponse: submitTxnsResponse,
+	}
+}
+
+// startWorker is the function that actually performs the underlying work of
+// the submit transaction worker.
+//
+// It is responsible for submitting transactions to Espresso, and handling
+// the response from Espresso.
+//
+// NOTE: This worker does not observe the context cancellation, as it is
+// expected to run until it is out of work.  Instead, it relies its job
+// queue being closed by the scheduler to indicate that no more work is left
+// for it to perform, then it will exit gracefully.
+func (w *submitTransactionWorker) startWorker(_ context.Context) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	ch := make(chan SubmitTransactionJob)
+
+	for {
+		// Submit our worker channel to the job queue
+		w.submitTxnsJobQueue <- ch
+		// Wait for a job to be sent to us
+		job, ok := <-ch
+		if !ok {
+			log.Warn("Submit transaction job queue closed, exiting", "worker", w.id)
+			return
+		}
+
+		// estimate the hash
+		commit := job.txn.Commit()
+		estimatedHash, err := tagged_base64.New("TX", commit[:])
+		if err != nil {
+			// This is unfortunate, but we shouldn't stop processing the job
+			// just because of a small reference failure.
+			log.Warn("Failed to estimate transaction hash", "error", err, "commit", common.Hash(commit), "worker", w.id)
+			estimatedHash = new(tagged_base64.TaggedBase64)
+		}
+
+		// Process the job
+		if job.attempt > 0 {
+			// If our attempts is greater than 0, it indicates that this isn't
+			// our first attempt at processing this job.  We want to avoid a
+			// scenario where we are hitting the Espresso Node with too many
+			// requests at once.  Since our job queue doesn't have any sense
+			// of time, the simplest way to handle this is just to sleep for
+			// a little bit longer each time we re-attempt processing the job.
+			// This will help to spread out the requests over time, and avoid
+			// overwhelming the Espresso Node.
+			//
+			// By applying this penalty here we also avoid a potential very
+			// active processing loop where we just requeue the job over and
+			// over without being able to make any progress.
+			time.Sleep(util.ConvertToInt64WithFallback[uint, time.Duration](job.attempt, 0) * w.delayPenalty)
+		}
+
+		log.Info("Submitting transaction to Espresso", "commit", common.Hash(job.txn.Commit()), "worker", w.id)
+
+		hash, err := w.client.SubmitTransaction(ctx, job.txn)
+		response := SubmitTransactionResponse{
+			job:  job,
+			hash: hash,
+		}
+		if err != nil {
+			response.err = ErrorSubmitTransactionFailed{Cause: err, WorkerID: w.id, EstimatedHash: *estimatedHash}
+		}
+
+		// Send the response back to the response handler
+		w.submitTxnsResponse <- response
+	}
+}
+
+// ErrorSubmitTransactionFailed is an error that is returned when submitting a
+// transaction to Espresso fails.
+type ErrorSubmitTransactionFailed struct {
+	Cause         error
+	WorkerID      uint64
+	EstimatedHash espresso_types.TaggedBase64
+}
+
+// Error implements error
+func (e ErrorSubmitTransactionFailed) Error() string {
+	return fmt.Sprintf("failed to submit transaction %s: %v", e.EstimatedHash.String(), e.Cause)
+}
+
+// Unwrap provides the underlying error for builtin errors checking
+func (e ErrorSubmitTransactionFailed) Unwrap() error {
+	return e.Cause
+}
diff --git a/espresso/submitter/submitter.go b/espresso/submitter/submitter.go
new file mode 100644
index 00000000000..b45c99bf3f8
--- /dev/null
+++ b/espresso/submitter/submitter.go
@@ -0,0 +1,411 @@
+package submitter
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"time"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+	espresso_light_client "github.com/EspressoSystems/espresso-network/sdks/go/light-client"
+
+	"github.com/ethereum/go-ethereum/ethdb"
+
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+	"github.com/offchainlabs/nitro/arbutil"
+	espresso_key_manager "github.com/offchainlabs/nitro/espresso/key-manager"
+	"github.com/offchainlabs/nitro/util"
+	"github.com/offchainlabs/nitro/util/stopwaiter"
+)
+
+type MessageGetter interface {
+	GetMessage(seqNum arbutil.MessageIndex) (*arbostypes.MessageWithMetadata, error)
+}
+
+type EspressoSubmitter interface {
+	Start(sw *stopwaiter.StopWaiter) error
+	NotifyNewPendingMessages(pos arbutil.MessageIndex, messages []arbostypes.MessageWithMetadataAndBlockInfo) error
+	GetKeyManager() espresso_key_manager.EspressoKeyManagerInterface
+	EnqueuePendingTransaction(pos []arbutil.MessageIndex) error
+}
+
+// EspressoSubmitterConfig holds the configuration options for implementations
+// of the [EspressoSubmitter] interface.
+type EspressoSubmitterConfig struct {
+	// Simple Configuration values. These will be expected to have default
+	// values set for them, but can be overridden by the user.
+
+	ChainID                               uint64
+	EspressoTxnsMonitoringInterval        time.Duration
+	EspressoTxnsResubmissionInterval      time.Duration
+	EspressoTxnSendingInterval            time.Duration
+	EspressoMaxTransactionSize            int64
+	ResubmitEspressoTxDeadline            time.Duration
+	InitialFinalizedSequencerMessageCount *big.Int
+
+	// These are attestation values that will signify information to load
+	// for attestation initialization
+
+	UserDataAttestationFile string
+	QuoteFile               string
+
+	// These are the interfaces that will be used to interact with
+	// Espresso, and the underlying chain information.
+
+	EspressoClient    espresso_client.EspressoClient
+	LightClientReader espresso_light_client.LightClientReaderInterface
+	KeyManager        espresso_key_manager.EspressoKeyManagerInterface
+	MessageGetter     MessageGetter
+	Db                ethdb.Database
+
+	CanSubmit func(ctx context.Context) (bool, error)
+
+	// These are specific to the Multi Worker Queue Espresso Submitter
+	// and governs how many workers / buffering is used for the
+	// Espresso Submitter.
+
+	NumberOfSubmitTransactionWorkers   uint64
+	NumberOfTransactionIncludedWorkers uint64
+	MessageIndexQueueSize              uint64
+	SubmitTransactionsQueueSize        uint64
+	TransactionIncludedQueueSize       uint64
+	SubmissionFailureDelayPenalty      time.Duration
+	VerificationFailureDelayPenalty    time.Duration
+	InitialNitroMessageAvailable       arbutil.MessageIndex
+	InitialNitroMessageToSubmit        arbutil.MessageIndex
+}
+
+// DefaultEspressoSubmitterConfig provides a default configuration for the
+// EspressoSubmitter.
+//
+// It includes default values for the following fields:
+// - EspressoTxnsPollingInterval
+// - EspressoTxnSendingInterval
+// - MaxBlockLagBeforeEscapeHatch
+// - EspressoMaxTransactionSize
+// - ResubmitEspressoTxDeadline
+// - InitialFinalizedSequencerMessageCount
+//
+// NOTE: The following fields are not set by default and must be provided:
+// - EspressoClient
+// - LightClientReader
+// - MessageGetter
+var DefaultEspressoSubmitterConfig = EspressoSubmitterConfig{
+	EspressoTxnsMonitoringInterval:        time.Second,
+	EspressoTxnSendingInterval:            time.Second,
+	EspressoMaxTransactionSize:            200_000,
+	ResubmitEspressoTxDeadline:            16 * time.Second,
+	InitialFinalizedSequencerMessageCount: big.NewInt(0),
+	NumberOfSubmitTransactionWorkers:      util.GetNumCPUs() * 2,
+	NumberOfTransactionIncludedWorkers:    util.GetNumCPUs() * 2,
+	SubmissionFailureDelayPenalty:         100 * time.Millisecond,
+	VerificationFailureDelayPenalty:       100 * time.Millisecond,
+	MessageIndexQueueSize:                 1024,
+	SubmitTransactionsQueueSize:           1024,
+	TransactionIncludedQueueSize:          1024,
+}
+
+// EspressoSubmitterConfigOption is a function type that takes a pointer to
+// [EspressoSubmitterConfig] and modifies it.
+//
+// This allows for flexible configuration of the EspressoSubmitter by
+// passing in various options to a variadic function based on the
+// [Functional Options] pattern.
+//
+// [Functional Options]: https://dave.cheney.net/2014/10/17/functional-options-for-friendly-apis
+type EspressoSubmitterConfigOption func(*EspressoSubmitterConfig)
+
+// applyEspressoSubmitterConfigOptions is a helper function that applies
+// a list of [EspressoSubmitterConfigOption] functions to the provided
+// [EspressoSubmitterConfig].
+func applyEspressoSubmitterConfigOptions(
+	config *EspressoSubmitterConfig,
+	options ...EspressoSubmitterConfigOption,
+) {
+	for _, option := range options {
+		option(config)
+	}
+}
+
+// WithMultipleOptions is a variadic function that takes multiple
+// [EspressoSubmitterConfigOption] functions and applies them to the provided
+// [EspressoSubmitterConfig].
+func WithMultipleOptions(options ...EspressoSubmitterConfigOption) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		applyEspressoSubmitterConfigOptions(config, options...)
+	}
+}
+
+func WithCanSubmit(canSubmit func(ctx context.Context) (bool, error)) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.CanSubmit = canSubmit
+	}
+}
+
+// WithChainID is an [EspressoSubmitterConfigOption] that sets the ChainID in
+// the [EspressoSubmitterConfig].
+func WithChainID(chainID uint64) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.ChainID = chainID
+	}
+}
+
+// WithMessageGetter is an [EspressoSubmitterConfigOption] that sets the
+// [MessageGetter] in the
+func WithMessageGetter(getter MessageGetter) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.MessageGetter = getter
+	}
+}
+
+// WithDatabase is an [EspressoSubmitterConfigOption] that sets the
+// [ethdb.Database]  in the [EspressoSubmitterConfig].
+func WithDatabase(db ethdb.Database) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.Db = db
+	}
+}
+
+// WithAttestationFiles is an [EspressoSubmitterConfigOption] that sets the
+// user data attestation file and quote file in the [EspressoSubmitterConfig].
+func WithAttestationFiles(userDataAttestationFile, quoteFile string) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.UserDataAttestationFile = userDataAttestationFile
+		config.QuoteFile = quoteFile
+	}
+}
+
+// WithEspressoClient is an [EspressoSubmitterConfigOption] that sets the
+// [espresso_client.EspressoClient] in the [EspressoSubmitterConfig].
+func WithEspressoClient(client espresso_client.EspressoClient) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.EspressoClient = client
+	}
+}
+
+// WithLightClientReader is an [EspressoSubmitterConfigOption] that sets the
+// [espresso_light_client.LightClientReaderInterface] in the
+// [EspressoSubmitterConfig].
+func WithLightClientReader(reader espresso_light_client.LightClientReaderInterface) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.LightClientReader = reader
+	}
+}
+
+// WithKeyManager is an [EspressoSubmitterConfigOption] that sets the
+// [espresso_key_manager.EspressoKeyManagerInterface] in the
+// [EspressoSubmitterConfig].
+func WithKeyManager(keyManager espresso_key_manager.EspressoKeyManagerInterface) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.KeyManager = keyManager
+	}
+}
+
+// WithMaxTransactionSize is an [EspressoSubmitterConfigOption] that sets the
+// maximum transaction size in the [EspressoSubmitterConfig].
+func WithMaxTransactionSize(size int64) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.EspressoMaxTransactionSize = size
+	}
+}
+
+// WithTxnsMonitoringInterval is an [EspressoSubmitterConfigOption] that sets the
+// transaction polling, resubmission, and submission interval
+func WithTxnsMonitoringInterval(interval time.Duration) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.EspressoTxnsMonitoringInterval = interval
+	}
+}
+
+// WithTxnsResubmissionInterval is an [EspressoSubmitterConfigOption] that sets
+// the transaction resubmission interval in the [EspressoSubmitterConfig].
+func WithTxnsResubmissionInterval(interval time.Duration) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.EspressoTxnsResubmissionInterval = interval
+	}
+}
+
+// WithResubmitEspressoTxDeadline is an [EspressoSubmitterConfigOption] that
+// sets the deadline for resubmitting Espresso transactions in the
+// [EspressoSubmitterConfig].
+func WithResubmitEspressoTxDeadline(deadline time.Duration) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.ResubmitEspressoTxDeadline = deadline
+	}
+}
+
+// WithUseEscapeHatch is an [EspressoSubmitterConfigOption] that sets whether
+// to use the escape hatch in the [EspressoSubmitterConfig].
+func WithInitialFinalizedSequencerMessageCount(count *big.Int) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.InitialFinalizedSequencerMessageCount = count
+	}
+}
+
+// WithNumberOfSubmitTransactionWorkers is an [EspressoSubmitterConfigOption]
+// that sets the number of workers for submitting transactions in the
+// [EspressoSubmitterConfig].
+//
+// NOTE: This is specific to the Multi Worker Queue Espresso Submitter.
+func WithNumberOfSubmitTransactionWorkers(numWorkers uint64) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.NumberOfSubmitTransactionWorkers = numWorkers
+	}
+}
+
+// WithNumberOfTransactionIncludedWorkers is an [EspressoSubmitterConfigOption]
+// that sets the number of workers for transaction inclusion in the
+// [EspressoSubmitterConfig].
+//
+// NOTE: This is specific to the Multi Worker Queue Espresso Submitter.
+func WithNumberOfTransactionIncludedWorkers(numWorkers uint64) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.NumberOfTransactionIncludedWorkers = numWorkers
+	}
+}
+
+// WithMessageIndexQueueSize is an [EspressoSubmitterConfigOption] that sets the
+// size of the message index queue in the [EspressoSubmitterConfig].
+//
+// NOTE: This is specific to the Multi Worker Queue Espresso Submitter.
+func WithMessageIndexQueueSize(size uint64) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.MessageIndexQueueSize = size
+	}
+}
+
+// WithSubmitTransactionsQueueSize is an [EspressoSubmitterConfigOption] that
+// sets the size of the submit transactions queue in the
+// [EspressoSubmitterConfig].
+//
+// NOTE: This is specific to the Multi Worker Queue Espresso Submitter.
+func WithSubmitTransactionsQueueSize(size uint64) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.SubmitTransactionsQueueSize = size
+	}
+}
+
+// WithTransactionIncludedQueueSize is an [EspressoSubmitterConfigOption] that
+// sets the size of the transaction included queue in the
+// [EspressoSubmitterConfig].
+//
+// NOTE: This is specific to the Multi Worker Queue Espresso Submitter.
+func WithTransactionIncludedQueueSize(size uint64) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.TransactionIncludedQueueSize = size
+	}
+}
+
+// WithSubmissionFailureDelayPenalty is an [EspressoSubmitterConfigOption] that
+// sets the delay penalty for submission failures in the
+// [EspressoSubmitterConfig].
+//
+// NOTE: this is currently specific to the Multi Worker Queue Espresso
+// Submitter.
+func WithSubmissionFailureDelayPenalty(penalty time.Duration) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.SubmissionFailureDelayPenalty = penalty
+	}
+}
+
+// WithVerificationFailureDelayPenalty is an [EspressoSubmitterConfigOption]
+// that sets the delay penalty for verification failures in the
+// [EspressoSubmitterConfig].
+//
+// NOTE: this is currently specific to the Multi Worker Queue Espresso
+// Submitter.
+func WithVerificationFailureDelayPenalty(penalty time.Duration) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.VerificationFailureDelayPenalty = penalty
+	}
+}
+
+// WithInitialNitroMessageAvailable is an [EspressoSubmitterConfigOption] that
+// sets the initial position, up to which the total number of nitro messages
+// should currently be available to process.
+//
+// This pre-configures the submitter with some indication of which message
+// indices are already available to be submitted to Espresso.
+//
+// NOTE: this is currently specific to the Multi Worker Queue Espresso
+// Submitter.
+func WithInitialNitroMessageAvailable(pos arbutil.MessageIndex) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.InitialNitroMessageAvailable = pos
+	}
+}
+
+// WithInitialNitroMessageToSubmit is an [EspressoSubmitterConfigOption] that
+// sets the position of the first nitro message we're looking to submit to
+// Espresso. This implies that every message prior to this index has already
+// been processed and confirmed in Espresso.
+//
+// This pre-configures the submitter with some indication of which message
+// indices are already pending submission to Espresso. This effectively
+// indicates the position at which the submitter should start attempting
+// to submit new transactions.
+//
+// NOTE: this is currently specific to the Multi Worker Queue Espresso
+// Submitter.
+func WithInitialNitroMessageToSubmit(pos arbutil.MessageIndex) EspressoSubmitterConfigOption {
+	return func(config *EspressoSubmitterConfig) {
+		config.InitialNitroMessageToSubmit = pos
+	}
+}
+
+// ValidateEspressoSubmitterConfig checks if the provided
+// [EspressoSubmitterConfig] is valid.
+//
+// It returns an error if any of the following required fields are set to their
+// zero value:
+// - EspressoClient
+// - MessageGetter
+// - Db
+// - KeyManager
+// - ChainID
+// - EspressoMaxTransactionSize
+// - EspressoTxnsPollingInterval
+// - EspressoTxnSendingInterval
+func ValidateEspressoSubmitterConfig(config EspressoSubmitterConfig) error {
+	if config.EspressoClient == nil {
+		return fmt.Errorf("espresso client is not set")
+	}
+
+	if config.MessageGetter == nil {
+		return fmt.Errorf("message getter is not set")
+	}
+
+	if config.Db == nil {
+		return fmt.Errorf("database is not set")
+	}
+
+	if config.KeyManager == nil {
+		return fmt.Errorf("espresso key manager is not set")
+	}
+
+	if config.ChainID == 0 {
+		return fmt.Errorf("chain ID is not set")
+	}
+
+	if config.EspressoMaxTransactionSize <= 0 {
+		return fmt.Errorf("espresso max transaction size must be greater than 0")
+	}
+
+	if config.EspressoTxnsMonitoringInterval <= 0 {
+		return fmt.Errorf("espresso transactions polling interval must be greater than 0")
+	}
+
+	if config.EspressoTxnsMonitoringInterval >= 2*time.Second {
+		return fmt.Errorf("espresso transactions polling interval must be 2 seconds or less")
+	}
+
+	if config.EspressoTxnSendingInterval <= 0 {
+		return fmt.Errorf("espresso transactions submission interval must be greater than 0")
+	}
+
+	if config.CanSubmit == nil {
+		return fmt.Errorf("espresso can submit is not set")
+	}
+
+	return nil
+}
diff --git a/espresso/submitter/transaction_included_worker.go b/espresso/submitter/transaction_included_worker.go
new file mode 100644
index 00000000000..dafaa8f09e5
--- /dev/null
+++ b/espresso/submitter/transaction_included_worker.go
@@ -0,0 +1,224 @@
+package submitter
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"time"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+	espresso_types "github.com/EspressoSystems/espresso-network/sdks/go/types"
+
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/offchainlabs/nitro/util"
+)
+
+// TransactionIncludedJob represents a job to check if a transaction is included
+// in Espresso.
+type TransactionIncludedJob struct {
+	txnHash        espresso_types.TaggedBase64
+	txn            espresso_types.Transaction
+	submitSuccess  time.Time
+	submitAttempts uint
+	attempt        uint
+	lastAttempt    time.Time
+}
+
+// TransactionIncludedResponse represents a response / result of a performed
+// TransactionIncludedJob task
+type TransactionIncludedResponse struct {
+	job                  TransactionIncludedJob
+	transactionQueryData espresso_types.TransactionQueryData
+	transactionsInBlock  espresso_client.TransactionsInBlock
+	index                int
+	err                  error
+}
+
+// transactionIncludedQueueWorker is a worker that processes
+// TransactionIncludedJob tasks.
+type transactionIncludedQueueWorker struct {
+	id                          uint64
+	chainID                     uint64
+	client                      espresso_client.EspressoClient
+	failurePenalty              time.Duration
+	transactionIncludedJobQueue chan<- chan TransactionIncludedJob
+	transactionIncludedResponse chan<- TransactionIncludedResponse
+}
+
+// newTransactionIncludedQueueWorker creates a new transaction included queue
+// worker with the given ID, client, job queue, and response channel.
+func newTransactionIncludedQueueWorker(
+	id uint64, chainID uint64, client espresso_client.EspressoClient,
+	failurePenalty time.Duration,
+	transactionIncludedJobQueue chan<- chan TransactionIncludedJob,
+	transactionIncludedResponse chan<- TransactionIncludedResponse,
+) *transactionIncludedQueueWorker {
+	return &transactionIncludedQueueWorker{
+		id:                          id,
+		chainID:                     chainID,
+		client:                      client,
+		failurePenalty:              failurePenalty,
+		transactionIncludedJobQueue: transactionIncludedJobQueue,
+		transactionIncludedResponse: transactionIncludedResponse,
+	}
+}
+
+// startWorker is the function that actually performs the underlying work of
+// the transaction included queue worker.
+//
+// It is responsible for checking if a transaction is included in Espresso,
+// and handling the response from Espresso.
+//
+// NOTE: This worker does not observe the context cancellation, as it is
+// expected to run until it is out of work.  Instead, it relies its job
+// queue being closed by the worker scheduler to indicate that no more
+// work is left for it to perform, then it will exit gracefully.
+func (w *transactionIncludedQueueWorker) startWorker(_ context.Context) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	ch := make(chan TransactionIncludedJob)
+	for {
+		// Submit our worker channel to the job queue
+		w.transactionIncludedJobQueue <- ch
+		// Wait for a job to be sent to us
+		job, ok := <-ch
+		if !ok {
+			log.Warn("Transaction inclusion job queue closed, exiting", "worker", w.id)
+			return
+		}
+		// Process the job
+
+		if job.attempt > 0 {
+			// If our attempts is greater than 0, it indicates that this isn't
+			// our first attempt at processing this job.  We want to avoid a
+			// scenario where we are hitting the Espresso Node with too many
+			// requests at once.  Since our job queue doesn't have any sense
+			// of time, the simplest way to handle this is just to sleep for
+			// a little bit longer each time we re-attempt processing the job.
+			// This will help to spread out the requests over time, and avoid
+			// overwhelming the Espresso Node.
+			//
+			// By applying this penalty here we also avoid a potential very
+			// active processing loop where we just requeue the job over and
+			// over without being able to make any progress.
+			log.Info("Re-attempting transaction inclusion check, applying delay penalty", "worker", w.id, "attempt", job.attempt, "delay", util.ConvertToInt64WithFallback[uint, time.Duration](job.attempt, 0)*w.failurePenalty)
+			time.Sleep(util.ConvertToInt64WithFallback[uint, time.Duration](job.attempt, 0) * w.failurePenalty)
+		}
+
+		details, err := w.client.FetchTransactionByHash(ctx, &job.txnHash)
+		if err != nil {
+			w.transactionIncludedResponse <- TransactionIncludedResponse{
+				job: job,
+				err: ErrorFetchTransactionByHashFailed{Cause: err, WorkerID: w.id, TxnHash: job.txnHash},
+			}
+			continue
+		}
+
+		// We need to verify the transaction in the block
+		txns, err := w.client.FetchTransactionsInBlock(ctx, details.BlockHeight, job.txn.Namespace)
+		if err != nil {
+			w.transactionIncludedResponse <- TransactionIncludedResponse{
+				job:                  job,
+				transactionQueryData: details,
+				err:                  ErrorFetchTransactionsForBlockAndNamespaceFailed{Cause: err, WorkerID: w.id, TxnHash: job.txnHash, BlockHeight: details.BlockHeight, Namespace: job.txn.Namespace},
+			}
+			continue
+		}
+
+		// One of the transactions in the block should match the txn payload
+		// we submitted
+		if index, isIncluded := w.doesTransactionExistInBlock(job, txns); isIncluded {
+			// We found the transaction in the block, so we can mark it as included
+			w.transactionIncludedResponse <- TransactionIncludedResponse{
+				job:                  job,
+				transactionQueryData: details,
+				transactionsInBlock:  txns,
+				index:                index,
+			}
+			continue
+		}
+
+		// If we reach here, it means the transaction was not found in
+		// the block
+		w.transactionIncludedResponse <- TransactionIncludedResponse{
+			job:                  job,
+			transactionQueryData: details,
+			transactionsInBlock:  txns,
+			index:                -1,
+			err:                  ErrorTransactionNotFoundInBlock{WorkerID: w.id, BlockHeight: details.BlockHeight, TxnHash: job.txnHash},
+		}
+	}
+}
+
+// doesTransactionExistInBlock checks if the transaction exists in the block
+// represented by the TransactionsInBlock object.
+//
+// This check is done by comparing the transaction payload with the
+// transactions in the block.  If a transaction with the same payload is found,
+// it is considered to be included in the block.
+func (w *transactionIncludedQueueWorker) doesTransactionExistInBlock(
+	job TransactionIncludedJob, txns espresso_client.TransactionsInBlock,
+) (int, bool) {
+	for i, txn := range txns.Transactions {
+		if bytes.Equal(txn, job.txn.Payload) {
+			return i, true
+		}
+	}
+	return -1, false
+}
+
+// ErrorFetchTransactionByHashFailed is an error that is returned when
+// fetching a transaction by its hash fails.
+//
+// It wraps the original error that caused the failure, and includes the
+// transaction hash that was being fetched.
+type ErrorFetchTransactionByHashFailed struct {
+	Cause    error
+	WorkerID uint64
+	TxnHash  espresso_types.TaggedBase64
+}
+
+// Error implements error
+func (e ErrorFetchTransactionByHashFailed) Error() string {
+	return fmt.Sprintf("failed to fetch transaction by hash %s: %v", e.TxnHash.String(), e.Cause)
+}
+
+// Unwrap provides the underlying error for builtin errors checking
+func (e ErrorFetchTransactionByHashFailed) Unwrap() error {
+	return e.Cause
+}
+
+// ErrorFetchTransactionsForBlockAndNamespaceFailed is an error that is
+// returned when fetching transactions for a specific block and namespace
+// fails.
+type ErrorFetchTransactionsForBlockAndNamespaceFailed struct {
+	Cause       error
+	WorkerID    uint64
+	BlockHeight uint64
+	Namespace   uint64
+	TxnHash     espresso_types.TaggedBase64
+}
+
+// Error implements error
+func (e ErrorFetchTransactionsForBlockAndNamespaceFailed) Error() string {
+	return fmt.Sprintf("failed to fetch transactions for block %d and namespace %d, determined from transaction hash: %s: %v", e.BlockHeight, e.Namespace, e.TxnHash.String(), e.Cause)
+}
+
+// Unwrap provides the underlying error for builtin errors checking
+func (e ErrorFetchTransactionsForBlockAndNamespaceFailed) Unwrap() error {
+	return e.Cause
+}
+
+// ErrorTransactionNotFoundInBlock is an error that is returned when a
+// transaction is not found in a specific block.
+type ErrorTransactionNotFoundInBlock struct {
+	WorkerID    uint64
+	TxnHash     espresso_types.TaggedBase64
+	BlockHeight uint64
+}
+
+// Error implements error
+func (e ErrorTransactionNotFoundInBlock) Error() string {
+	return fmt.Sprintf("transaction %s not found in block %d", e.TxnHash.String(), e.BlockHeight)
+}
diff --git a/espresso/test-utils/test-utils.go b/espresso/test-utils/test-utils.go
new file mode 100644
index 00000000000..b6e84ab971b
--- /dev/null
+++ b/espresso/test-utils/test-utils.go
@@ -0,0 +1,40 @@
+package testutils
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+)
+
+func CreateDummyEspressoMetadata(t *testing.T) []byte {
+	hotshotHeight := new(big.Int).SetUint64(1)
+	signature := make([]byte, 32)
+	teeType := uint8(0)
+
+	uint256Type, err := abi.NewType("uint256", "", nil)
+	if err != nil {
+		t.Fatal("failed to create uint256 type")
+	}
+
+	bytesType, err := abi.NewType("bytes", "", nil)
+	if err != nil {
+		t.Fatal("failed to create bytes type")
+	}
+
+	uint8Type, err := abi.NewType("uint8", "", nil)
+	if err != nil {
+		t.Fatal("failed to create uint8 type")
+	}
+
+	espressoMetadata, err := abi.Arguments{
+		{Type: uint256Type},
+		{Type: bytesType},
+		{Type: uint8Type},
+	}.Pack(hotshotHeight, signature, teeType)
+	if err != nil {
+		t.Fatal("failed to pack hotshot height and signature")
+	}
+
+	return espressoMetadata
+}
diff --git a/espresso/view-store/view_store_binary_tree.go b/espresso/view-store/view_store_binary_tree.go
new file mode 100644
index 00000000000..1fb1644d6bc
--- /dev/null
+++ b/espresso/view-store/view_store_binary_tree.go
@@ -0,0 +1,102 @@
+package view_store
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type View struct {
+	viewNumber        uint64
+	builderCommitment string
+	stateHash         common.Hash
+}
+
+// ViewStoreBinaryTree is a binary tree
+// storing the state hashes of the nitro state
+// at a given view number and payload commitment
+type ViewStoreBinaryTree struct {
+	View  View
+	Left  *ViewStoreBinaryTree
+	Right *ViewStoreBinaryTree
+}
+
+// Insert inserts a view into the view store binary tree, on the left side of the tree all the views
+// with a view number and builder commitment less than the root's view number are stored. On the right side
+// all the views with a view number and builder commitment greater than the root's view number are stored.
+func Insert(root *ViewStoreBinaryTree, viewNumber uint64, builderCommitment string, stateHash common.Hash) *ViewStoreBinaryTree {
+	if root == nil {
+		return &ViewStoreBinaryTree{
+			View: View{
+				viewNumber:        viewNumber,
+				builderCommitment: builderCommitment,
+				stateHash:         stateHash,
+			},
+		}
+	}
+	if viewNumber < root.View.viewNumber {
+		root.Left = Insert(root.Left, viewNumber, builderCommitment, stateHash)
+		return root
+	}
+
+	if viewNumber > root.View.viewNumber {
+		root.Right = Insert(root.Right, viewNumber, builderCommitment, stateHash)
+		return root
+	}
+
+	// This means that view numbers is equal to the root's view number
+	// Builder commitment might be different so we insert based on that now
+	if builderCommitment < root.View.builderCommitment {
+		root.Left = Insert(root.Left, viewNumber, builderCommitment, stateHash)
+		return root
+	}
+
+	if builderCommitment > root.View.builderCommitment {
+		root.Right = Insert(root.Right, viewNumber, builderCommitment, stateHash)
+		return root
+	}
+
+	// This means that the view numbers are equal and the builder commitment is equal
+	return root
+}
+
+/*
+Search searches for a view with a given view number and builder commitment
+*/
+func Search(root *ViewStoreBinaryTree, viewNumber uint64, builderCommitment string) *ViewStoreBinaryTree {
+	if root == nil {
+		return nil
+	}
+	if viewNumber < root.View.viewNumber {
+		return Search(root.Left, viewNumber, builderCommitment)
+	}
+
+	if viewNumber > root.View.viewNumber {
+		return Search(root.Right, viewNumber, builderCommitment)
+	}
+
+	if builderCommitment < root.View.builderCommitment {
+		return Search(root.Left, viewNumber, builderCommitment)
+	}
+
+	if builderCommitment > root.View.builderCommitment {
+		return Search(root.Right, viewNumber, builderCommitment)
+	}
+	return root
+}
+
+// Delete removes all nodes with viewNumber <= cutoff.
+func Delete(root *ViewStoreBinaryTree, cutoff uint64) *ViewStoreBinaryTree {
+	if root == nil {
+		return nil
+	}
+
+	if root.View.viewNumber > cutoff {
+		// Keep this node; only the left subtree can contain nodes to delete.
+		root.Left = Delete(root.Left, cutoff)
+		return root
+	}
+
+	// root.View.viewNumber <= cutoff:
+	// Drop this node and its entire left subtree.
+	// Continue deleting in the right subtree (may contain ties == cutoff).
+	return Delete(root.Right, cutoff)
+}
diff --git a/espresso/view-store/view_store_binary_tree_test.go b/espresso/view-store/view_store_binary_tree_test.go
new file mode 100644
index 00000000000..cfbfc6af0ca
--- /dev/null
+++ b/espresso/view-store/view_store_binary_tree_test.go
@@ -0,0 +1,279 @@
+package view_store
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+func mkHash(s string) common.Hash { return common.BytesToHash([]byte(s)) }
+
+func MakeInitialTree(t *testing.T) *ViewStoreBinaryTree {
+	root := Insert(nil, 5, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgA_", mkHash("1"))
+	root = Insert(root, 2, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgB_", mkHash("2"))
+	root = Insert(root, 7, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgC_", mkHash("3"))
+	return root
+}
+
+func TestEspressoViewStoreInsert(t *testing.T) {
+	t.Run("Insert view on the left side of the tree", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		// Now insert a view which has a view number which is less than the root's view number
+		root = Insert(root, 0, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_", mkHash("0"))
+
+		// Search for view number 2
+		viewStoreForViewNumvber2 := Search(root, 2, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgB_")
+		viewStoreForViewNumvber0 := Search(root, 0, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_")
+
+		// Check that left child has view number 0
+		if viewStoreForViewNumvber2.Left.View.viewNumber != 0 {
+			t.Errorf("Expected left child's view number to be 0, got %d", viewStoreForViewNumvber2.Left.View.viewNumber)
+		}
+
+		if viewStoreForViewNumvber0.View.viewNumber != 0 {
+			t.Errorf("Expected root's view number to be 0, got %d", viewStoreForViewNumvber0.View.viewNumber)
+		}
+		if viewStoreForViewNumvber0.View.builderCommitment != "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_" {
+			t.Errorf("Expected root's builder commitment to be BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_, got %s", viewStoreForViewNumvber0.View.builderCommitment)
+		}
+
+	})
+
+	t.Run("Insert view on the right side of the tree", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		// Now insert a view which has a view number which is less than the root's view number
+		root = Insert(root, 9, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_", mkHash("9"))
+
+		// Now check that its parent should be view number 7
+		viewStoreForViewNumber7 := Search(root, 7, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgC_")
+
+		// Check that the right side of view store 7 is the inserted view
+		if viewStoreForViewNumber7.Right.View.viewNumber != 9 {
+			t.Errorf("Expected right side of view store 7 to be 9, got %d", viewStoreForViewNumber7.Right.View.viewNumber)
+		}
+		if viewStoreForViewNumber7.Right.View.builderCommitment != "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_" {
+			t.Errorf("Expected right side of view store 7 to be BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_, got %s", viewStoreForViewNumber7.Right.View.builderCommitment)
+		}
+
+	})
+
+	t.Run("Insert a view which has the same view number but higher builder commitment", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		// Now insert a view which has the same view number but higher builder commitment
+		root = Insert(root, 5, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_", mkHash("4"))
+
+		// Now check that its parent view should be 5 view store with lower builder commitment
+		viewStoreForViewNumber5HigherBuilderCommitment := Search(root, 5, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_")
+		viewStoreFor7ViewNumber := Search(root, 7, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgC_")
+
+		// Check that the lower builder commitment view store 5 exists on the left side of view store 7
+		if viewStoreFor7ViewNumber.Left.View.viewNumber != 5 {
+			t.Errorf("Expected left side of view store for view number 7 to have view number 5, got %d", viewStoreFor7ViewNumber.Left.View.viewNumber)
+		}
+		if viewStoreFor7ViewNumber.Left.View.builderCommitment != "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_" {
+			t.Errorf("Expected left side of view store for view number 7 to have builder commitment BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_, got %s", viewStoreForViewNumber5HigherBuilderCommitment.Left.View.builderCommitment)
+		}
+	})
+
+	t.Run("Insert a view which has the same view number but lower builder commitment", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		// Now insert a view which has the same view number but lower builder commitment
+		root = Insert(root, 5, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcg0_", mkHash("4"))
+
+		viewStoreFor2ViewNumber := Search(root, 2, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgB_")
+
+		// Check that the lower builder commitment view store 5 exists on the right side of view store 2
+		if viewStoreFor2ViewNumber.Right.View.viewNumber != 5 {
+			t.Errorf("Expected right side of view store for view number 2 to have view number 5, got %d", viewStoreFor2ViewNumber.Left.View.viewNumber)
+		}
+		if viewStoreFor2ViewNumber.Right.View.builderCommitment != "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcg0_" {
+			t.Errorf("Expected right side of view store for view number 2 to have builder commitment BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcg0_, got %s", viewStoreFor2ViewNumber.Left.View.builderCommitment)
+		}
+	})
+
+}
+
+func TestEspressoViewStoreSearch(t *testing.T) {
+	t.Run("Search view on the left side of the tree", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		// Now insert a view which has a view number which is less than the root's view number
+		root = Insert(root, 0, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_", mkHash("0"))
+
+		// Search for view number 2
+		viewStoreForViewNumber0 := Search(root, 0, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_")
+
+		if viewStoreForViewNumber0.View.viewNumber != 0 {
+			t.Errorf("Expected root's view number to be 0, got %d", viewStoreForViewNumber0.View.viewNumber)
+		}
+		if viewStoreForViewNumber0.View.builderCommitment != "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_" {
+			t.Errorf("Expected root's builder commitment to be BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_, got %s", viewStoreForViewNumber0.View.builderCommitment)
+		}
+	})
+
+	t.Run("Search view on the right side of the tree", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		root = Insert(root, 10, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgB_", mkHash("2"))
+		// Search for view number 2
+		viewStoreForViewNumber2 := Search(root, 10, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgB_")
+
+		if viewStoreForViewNumber2.View.viewNumber != 10 {
+			t.Errorf("Expected right child's view number to be 10, got %d", viewStoreForViewNumber2.Right.View.viewNumber)
+		}
+		if viewStoreForViewNumber2.View.builderCommitment != "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgB_" {
+			t.Errorf("Expected right child's builder commitment to be BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgB_, got %s", viewStoreForViewNumber2.Right.View.builderCommitment)
+		}
+	})
+
+	t.Run("search for a view number which is equal to one of the view numbers but has a greater builder commitment", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		// Insert a view which has a view number which is equal to the root's view number
+		// but has a greater builder commitment
+		root = Insert(root, 2, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_", mkHash("4"))
+
+		// Search for view number 2
+		viewStoreForViewNumber2 := Search(root, 2, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_")
+
+		if viewStoreForViewNumber2.View.viewNumber != 2 {
+			t.Errorf("Expected  view number to be 2, got %d", viewStoreForViewNumber2.Right.View.viewNumber)
+		}
+		if viewStoreForViewNumber2.View.builderCommitment != "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_" {
+			t.Errorf("Expected  builder commitment to be BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_, got %s", viewStoreForViewNumber2.Right.View.builderCommitment)
+		}
+	})
+
+	t.Run("search for a view number which is equal to one of the view numbers but has a lower builder commitment", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		// Insert a view which has a view number which is equal to the root's view number
+		// but has a lower builder commitment
+		root = Insert(root, 2, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgA_", mkHash("4"))
+
+		// Search for view number 2
+		viewStoreForViewNumber2 := Search(root, 2, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgA_")
+
+		if viewStoreForViewNumber2.View.viewNumber != 2 {
+			t.Errorf("Expected  view number to be 2, got %d", viewStoreForViewNumber2.View.viewNumber)
+		}
+		if viewStoreForViewNumber2.View.builderCommitment != "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgA_" {
+			t.Errorf("Expected  builder commitment to be BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgA_, got %s", viewStoreForViewNumber2.View.builderCommitment)
+		}
+	})
+
+	t.Run("search for a view number which doesnt exist", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		// Search for view number 2
+		viewStore := Search(root, 3, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgB_")
+
+		if viewStore != nil {
+			t.Errorf("Expected view store to be nil, got %v", viewStore)
+		}
+	})
+
+	t.Run("search for a view which has a given view number but builder commitment which doesnt exist", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		// Search for view number 2
+		viewStore := Search(root, 2, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgK_")
+
+		if viewStore != nil {
+			t.Errorf("Expected view store to be nil, got %v", viewStore)
+		}
+	})
+}
+
+func TestViewStoreDelete(t *testing.T) {
+	t.Run("Delete a view which has a view number less than the root's view number", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		// Delete view number 0
+		root = Delete(root, 2)
+
+		// Check that now no element exits on the left side of the tree
+		if root.Left != nil {
+			t.Errorf("Expected left child to be nil, got %v", root.Left)
+		}
+	})
+
+	t.Run("Delete a view which has a view number greater than the root's view number", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		// Delete view number 0
+		root = Delete(root, 7)
+
+		// It should have deleted the whole tree
+		if root != nil {
+			t.Errorf("Expected root to be nil, got %v", root)
+		}
+
+		root = MakeInitialTree(t)
+
+		// Insert a view number 10 and 8
+		root = Insert(root, 10, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgB_", mkHash("2"))
+		root = Insert(root, 8, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgB_", mkHash("2"))
+
+		// Delete view number 7
+		root = Delete(root, 7)
+
+		// root view number should be 10
+		if root.View.viewNumber != 10 {
+			t.Errorf("Expected root view number to be 10, got %d", root.View.viewNumber)
+		}
+
+		// Search and there should be no view with view number 7
+		viewStore := Search(root, 7, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgB_")
+		if viewStore != nil {
+			t.Errorf("Expected view store to be nil, got %v", viewStore)
+		}
+	})
+
+	t.Run("Delete a view which has a view number equal to one of the views but higher builder commitment", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		// Insert a view number 2 but with a higher builder commitment
+		root = Insert(root, 2, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgF_", mkHash("4"))
+		// Delete view number 0
+		root = Delete(root, 2)
+
+		// There should now be no left child of the root
+		if root.Left != nil {
+			t.Errorf("Expected left child to be nil, got %v", root.Left)
+		}
+	})
+
+	t.Run("Delete a view which has a view number equal to one of the views but lower builder commitment", func(t *testing.T) {
+		root := MakeInitialTree(t)
+
+		// Insert a view number 2 but with a lower builder commitment
+		root = Insert(root, 7, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgA_", mkHash("4"))
+		// Delete view number 0
+		root = Delete(root, 7)
+
+		// now the whole tree should be deleted
+		if root != nil {
+			t.Errorf("Expected root to be nil, got %v", root)
+		}
+
+		root = MakeInitialTree(t)
+		// Insert a view number 10 and 8
+		root = Insert(root, 10, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgB_", mkHash("2"))
+		root = Insert(root, 8, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgB_", mkHash("2"))
+
+		// Insert a lower builder commitment for view 8 and delete view number 8
+		root = Insert(root, 8, "BUILDER_COMMITMENT~tEvs0rxqOiMCvfe2R0omNNaphSlUiEDrb2q0IZpRcgA_", mkHash("2"))
+		root = Delete(root, 8)
+
+		// root view number should be 10
+		if root.View.viewNumber != 10 {
+			t.Errorf("Expected root view number to be 10, got %d", root.View.viewNumber)
+		}
+	})
+
+}
diff --git a/espressostreamer/espresso_streamer.go b/espressostreamer/espresso_streamer.go
new file mode 100644
index 00000000000..56de1d42e7d
--- /dev/null
+++ b/espressostreamer/espresso_streamer.go
@@ -0,0 +1,539 @@
+package espressostreamer
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	espressoClient "github.com/EspressoSystems/espresso-network/sdks/go/client"
+	espressoTypes "github.com/EspressoSystems/espresso-network/sdks/go/types"
+	"github.com/ccoveille/go-safecast"
+	"github.com/spf13/pflag"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rlp"
+
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+	"github.com/offchainlabs/nitro/arbutil"
+	"github.com/offchainlabs/nitro/espressotee"
+	"github.com/offchainlabs/nitro/util"
+	"github.com/offchainlabs/nitro/util/stopwaiter"
+)
+
+const HOTSHOT_RANGE_LIMIT = 100
+
+var (
+	ErrFailedToFetchTransactions  = errors.New("failed to fetch transactions")
+	ErrPayloadHadNoMessages       = errors.New("ParseHotShotPayload found no messages, the transaction may be empty")
+	ErrUserDataHashNot32Bytes     = errors.New("user data hash is not 32 bytes")
+	ErrRetryParsingHotShotPayload = errors.New("failed to parse hotshot payload, but need retry")
+)
+
+type EspressoStreamerInterface interface {
+	Start(ctx context.Context) error
+	Next() *MessageWithMetadataAndPos
+	// Peek returns the next message in the streamer's buffer. If the message is not
+	// in the buffer, it will return nil.
+	Peek() *MessageWithMetadataAndPos
+	// Advance moves the current message position to the next message.
+	Advance()
+	// Reset sets the current message position and the next hotshot block number.
+	Reset(currentMessagePos uint64, currentHostshotBlock uint64)
+	// RecordTimeDurationBetweenHotshotAndCurrentBlock records the time duration between
+	// the next hotshot block and the current block.
+	RecordTimeDurationBetweenHotshotAndCurrentBlock(nextHotshotBlock uint64, blockProductionTime time.Time)
+	GetCurrentEarliestHotShotBlockNumber(pos uint64) uint64
+
+	SetBatcherAddressesFetcher(fetcher func(l1Height uint64, address common.Address) (bool, error))
+	CanBatcherAddressSend(ctx context.Context, address common.Address) (bool, error)
+	StopAndWait()
+}
+
+type MessageWithMetadataAndPos struct {
+	MessageWithMeta arbostypes.MessageWithMetadata
+	Pos             uint64
+	HotshotHeight   uint64
+}
+
+type EspressoStreamerConfig struct {
+	HotShotBlock          uint64        `koanf:"hotshot-block"`
+	TxnsPollingInterval   time.Duration `koanf:"txns-polling-interval"`
+	AddressMonitorStartL1 uint64        `koanf:"address-monitor-start-l1"`
+	AddressMonitorStep    uint64        `koanf:"address-monitor-step"`
+}
+
+var DefaultEspressoStreamerConfig = EspressoStreamerConfig{
+	HotShotBlock: 1,
+	// Hotshot currently produces blocks at average of 2 seconds
+	// We set it to 1 second to get updates more often than blocks are produced
+	TxnsPollingInterval:   time.Second,
+	AddressMonitorStartL1: 1,
+	AddressMonitorStep:    100,
+}
+
+func EspressoStreamerConfigAddOptions(prefix string, f *pflag.FlagSet) {
+	f.Uint64(prefix+".hotshot-block", DefaultEspressoStreamerConfig.HotShotBlock, "specifies the hotshot block number to start the espresso streamer on")
+	f.Uint64(prefix+".address-monitor-step", DefaultEspressoStreamerConfig.AddressMonitorStep, "specifies the number of blocks at a time to query when searching for logs emitted for updating valid batcher addresses.")
+	f.Uint64(prefix+".address-monitor-start-l1", DefaultEspressoStreamerConfig.AddressMonitorStartL1, "specifies the l1 block number when this rollup started posting to monitor addresses")
+	f.Duration(prefix+".txns-polling-interval", DefaultEspressoStreamerConfig.TxnsPollingInterval, "interval between polling for transactions to be included in the block")
+}
+
+type EspressoStreamer struct {
+	stopwaiter.StopWaiter
+	espressoClient            espressoClient.EspressoClient
+	nextHotshotBlockNum       uint64
+	currentMessagePos         uint64
+	namespace                 uint64
+	messageWithMetadataAndPos map[uint64]*MessageWithMetadataAndPos
+	espressoSGXVerifier       espressotee.EspressoSGXVerifierInterface
+	highestPos                uint64
+
+	messageLock sync.RWMutex
+	retryTime   time.Duration
+
+	PerfRecorder *PerfRecorder
+
+	batcherAddressesFetcher func(l1Height uint64, address common.Address) (bool, error)
+}
+
+var _ EspressoStreamerInterface = (*EspressoStreamer)(nil)
+
+func NewEspressoStreamer(
+	namespace uint64,
+	nextHotshotBlockNum uint64,
+	espressoSGXVerifier espressotee.EspressoSGXVerifierInterface,
+	espressoClient espressoClient.EspressoClient,
+	recordPerformance bool,
+	batcherAddressesFetcher func(l1Height uint64, address common.Address) (bool, error),
+	retryTime time.Duration,
+) *EspressoStreamer {
+
+	var PerfRecorder *PerfRecorder
+	if recordPerformance {
+		PerfRecorder = NewPerfRecorder()
+	}
+
+	return &EspressoStreamer{
+		espressoClient:            espressoClient,
+		nextHotshotBlockNum:       nextHotshotBlockNum,
+		namespace:                 namespace,
+		espressoSGXVerifier:       espressoSGXVerifier,
+		PerfRecorder:              PerfRecorder,
+		batcherAddressesFetcher:   batcherAddressesFetcher,
+		retryTime:                 retryTime,
+		currentMessagePos:         1,
+		messageWithMetadataAndPos: make(map[uint64]*MessageWithMetadataAndPos),
+		highestPos:                1,
+	}
+}
+
+func (s *EspressoStreamer) CanBatcherAddressSend(ctx context.Context, address common.Address) (bool, error) {
+	if s.batcherAddressesFetcher == nil {
+		return false, errors.New("batcher addresses fetcher not set")
+	}
+	latest, err := s.espressoClient.FetchLatestBlockHeight(ctx)
+	if err != nil {
+		return false, fmt.Errorf("failed to fetch espresso latest block height: %w", err)
+	}
+	// Even though we can query the latest block height, the node may not yet serve
+	// the header at that exact height. Using `latest-1` avoids spurious errors
+	// where this function would otherwise always fail. This is safe because
+	// Espresso block production is much faster than L1, and the L1 lag has
+	// already been accounted for in the batcher address monitor.
+	// TODO: Figure out why this doesn't work without `-1`.
+	// It might be just a dev node issue.
+	header, err := s.espressoClient.FetchHeaderByHeight(ctx, latest-1)
+	if err != nil {
+		return false, fmt.Errorf("failed to fetch espresso block header: %w", err)
+	}
+	l1Finalized := header.Header.GetL1Finalized()
+	if l1Finalized == nil {
+		return false, fmt.Errorf("l1 finalized not found")
+	}
+	return s.batcherAddressesFetcher(l1Finalized.Number, address)
+}
+
+// GetMessageCount
+// This function counts the consecutive positions from `currentMessagePos`.
+// Parameters:
+//
+//	None
+//
+// Return value:
+//
+//	a uint64 representing the estimated message count.
+func (s *EspressoStreamer) GetMessageCount() uint64 {
+	s.messageLock.RLock()
+	defer s.messageLock.RUnlock()
+	count := s.currentMessagePos
+	for {
+		if _, ok := s.messageWithMetadataAndPos[count]; !ok {
+			return count
+		}
+		count++
+	}
+}
+
+func (s *EspressoStreamer) Reset(currentMessagePos uint64, currentHotshotBlock uint64) {
+	s.messageLock.Lock()
+	defer s.messageLock.Unlock()
+
+	hotshotBlockNum := currentHotshotBlock
+
+	s.currentMessagePos = currentMessagePos
+	s.nextHotshotBlockNum = hotshotBlockNum
+	s.highestPos = currentMessagePos
+	s.messageWithMetadataAndPos = make(map[uint64]*MessageWithMetadataAndPos)
+}
+
+func (s *EspressoStreamer) Next() *MessageWithMetadataAndPos {
+	result := s.Peek()
+	if result == nil {
+		return nil
+	}
+
+	// Advance the current message position, so that the next call to
+	// `Peek` or `Next` will return the next message
+	s.Advance()
+	return result
+}
+
+func (s *EspressoStreamer) Peek() *MessageWithMetadataAndPos {
+	s.messageLock.RLock()
+	defer s.messageLock.RUnlock()
+
+	return s.messageWithMetadataAndPos[s.currentMessagePos]
+}
+
+func (s *EspressoStreamer) GetMsg(pos uint64) *MessageWithMetadataAndPos {
+	s.messageLock.RLock()
+	defer s.messageLock.RUnlock()
+
+	return s.messageWithMetadataAndPos[pos]
+}
+
+// Call this function to advance the streamer to the next message
+func (s *EspressoStreamer) Advance() {
+	s.messageLock.Lock()
+	defer s.messageLock.Unlock()
+	delete(s.messageWithMetadataAndPos, s.currentMessagePos)
+	s.currentMessagePos += 1
+}
+
+func (s *EspressoStreamer) AdvanceTo(toPos uint64) {
+	s.messageLock.Lock()
+	defer s.messageLock.Unlock()
+	if toPos <= s.currentMessagePos {
+		return
+	}
+
+	for pos := s.currentMessagePos; pos < toPos; pos++ {
+		delete(s.messageWithMetadataAndPos, pos)
+	}
+
+	s.currentMessagePos = toPos
+}
+
+// This function keep fetching hotshot blocks and parsing them until the condition is met.
+// It is a do-while loop, which means it will always execute at least once.
+//
+// Expose the *parseHotShotPayloadFn* to the caller for testing purposes
+func (s *EspressoStreamer) QueueMessagesFromHotshot(
+	ctx context.Context,
+	parseHotShotPayloadFn func(tx espressoTypes.Bytes, l1Height uint64) error,
+) error {
+	startHotshotBlockNum := s.nextHotshotBlockNum
+	toBlock, err := fetchNextHotshotBlock(
+		ctx,
+		s.espressoClient,
+		startHotshotBlockNum,
+		parseHotShotPayloadFn,
+		s.namespace,
+	)
+	if err != nil {
+		return err
+	}
+
+	s.messageLock.Lock()
+	defer s.messageLock.Unlock()
+	// Case where we call `reset()` we dont want to jump to `toBlock`
+	if s.nextHotshotBlockNum == startHotshotBlockNum {
+		s.nextHotshotBlockNum = toBlock
+	}
+	return nil
+}
+
+func (s *EspressoStreamer) verifyBatchPosterSignature(signature []byte, userDataHash [32]byte, l1Height uint64) error {
+	publicKey, err := crypto.SigToPub(userDataHash[:], signature)
+	if err != nil {
+		return fmt.Errorf("failed to convert signature to public key: %w", err)
+	}
+	addr := crypto.PubkeyToAddress(*publicKey)
+	valid, err := s.batcherAddressesFetcher(l1Height, addr)
+	if err != nil {
+		log.Warn("failed to get valid addresses", "err", err)
+		return ErrRetryParsingHotShotPayload
+	}
+	if !valid {
+		log.Error("address not valid", "addr", addr)
+		// Address not valid. Need to catch up
+		return fmt.Errorf("address not valid: %v", addr)
+	}
+	return nil
+}
+
+func (s *EspressoStreamer) GetCurrentEarliestHotShotBlockNumber(pos uint64) uint64 {
+	s.messageLock.RLock()
+	defer s.messageLock.RUnlock()
+	if len(s.messageWithMetadataAndPos) == 0 {
+		// This case means that the espresso streamer is empty and the earliest hotshot block number
+		// is the next hotshot block number.
+		return s.nextHotshotBlockNum
+	}
+	if msg, exists := s.messageWithMetadataAndPos[pos]; exists {
+		return msg.HotshotHeight
+	}
+
+	// Case where pos may not be found, but we have other positions
+	minHeight := s.nextHotshotBlockNum
+	for nextPos := pos; nextPos <= s.highestPos; nextPos++ {
+		if msg, ok := s.messageWithMetadataAndPos[nextPos]; ok && msg.HotshotHeight < minHeight {
+			minHeight = msg.HotshotHeight
+		}
+	}
+	return minHeight
+}
+
+/* Verify the attestation quote */
+func (s *EspressoStreamer) verifyLegacy(attestation []byte, signature [32]byte) error {
+	// as of 02/10/2025 there has never been an sgx TEE Caff Node that has signed a transaction meant to be checked by the verify function.
+	// Therefore we can hard code espressotee.BatchPoster as we will only ever need to check batch poster pcr0 values
+	// to verify the signature on messages.
+	_, err := s.espressoSGXVerifier.Verify(nil, attestation, signature)
+	if err == nil {
+		return nil
+	}
+
+	if !strings.Contains(err.Error(), "execution reverted") {
+		log.Warn("failed to verify sgx attestation quote", "err", err)
+		return ErrRetryParsingHotShotPayload
+	}
+	return err
+}
+
+func (s *EspressoStreamer) parseEspressoTransaction(tx espressoTypes.Bytes, l1Height uint64) error {
+	signature, userDataHash, indices, messages, err := arbutil.ParseHotShotPayload(tx)
+	if err != nil {
+		log.Warn("failed to parse hotshot payload", "err", err)
+		return err
+	}
+	if len(messages) == 0 {
+		return ErrPayloadHadNoMessages
+	}
+	if len(userDataHash) != 32 {
+		log.Warn("user data hash is not 32 bytes")
+		return ErrUserDataHashNot32Bytes
+	}
+
+	userDataHashArr := [32]byte(userDataHash)
+
+	var success bool
+	err = s.verifyBatchPosterSignature(signature, userDataHashArr, l1Height)
+	if err == nil {
+		success = true
+	} else if strings.Contains(err.Error(), ErrRetryParsingHotShotPayload.Error()) {
+		log.Warn("retrying to verify batch poster signature", "err", err)
+		return err
+	} else {
+		log.Warn("failed to verify batch poster signature", "err", err)
+	}
+
+	if !success && s.espressoSGXVerifier != nil {
+		err = s.verifyLegacy(signature, userDataHashArr)
+		if err != nil {
+			log.Warn("failed to verify attestation quote", "err", err)
+			return err
+		}
+		success = true
+	}
+
+	// do not proceed with message parsing if the all signature verification paths failed
+	if !success {
+		return fmt.Errorf("all signature verification paths failed for HotShot payload")
+	}
+
+	s.messageLock.Lock()
+	defer s.messageLock.Unlock()
+	for i, message := range messages {
+		var messageWithMetadata arbostypes.MessageWithMetadata
+		err = rlp.DecodeBytes(message, &messageWithMetadata)
+		if err != nil {
+			log.Warn("failed to decode message", "err", err)
+			// Instead of returnning an error, we should just skip this message
+			continue
+		}
+
+		if indices[i] < s.currentMessagePos {
+			log.Warn("message index is less than current message pos, skipping", "msgPos", indices[i], "currentMessagePos", s.currentMessagePos)
+			continue
+		}
+
+		msg := &MessageWithMetadataAndPos{
+			MessageWithMeta: messageWithMetadata,
+			Pos:             indices[i],
+			HotshotHeight:   s.nextHotshotBlockNum,
+		}
+
+		s.messageWithMetadataAndPos[msg.Pos] = msg
+
+		if msg.Pos > s.highestPos {
+			s.highestPos = msg.Pos
+		}
+
+		// Check if we have a higher position in an earlier block
+		currHeight := msg.HotshotHeight
+		for nextPos := msg.Pos + 1; nextPos <= s.highestPos; nextPos++ {
+			if higherPos, ok := s.messageWithMetadataAndPos[nextPos]; ok && higherPos.HotshotHeight < currHeight {
+				s.messageWithMetadataAndPos[msg.Pos].HotshotHeight = higherPos.HotshotHeight
+				currHeight = higherPos.HotshotHeight
+			}
+		}
+
+		log.Info("Added message to queue", "message", indices[i])
+	}
+	return nil
+}
+
+func (s *EspressoStreamer) getEspressoBlockTimestamp(ctx context.Context, blockHeight uint64) (time.Time, error) {
+	header, err := s.espressoClient.FetchHeaderByHeight(ctx, blockHeight)
+	if err != nil {
+		return time.Time{}, fmt.Errorf("unable to fetch header for hotshot block: %w", err)
+	}
+	seconds, err := safecast.ToInt64(header.Header.GetTimestamp())
+	if err != nil {
+		return time.Time{}, fmt.Errorf("unable to cast timestamp to int64: %w", err)
+	}
+	return time.Unix(seconds, 0), nil
+}
+
+func (s *EspressoStreamer) RecordTimeDurationBetweenHotshotAndCurrentBlock(nextHotshotBlock uint64, blockProductionTime time.Time) {
+	if s.PerfRecorder != nil {
+		timestamp, err := s.getEspressoBlockTimestamp(context.Background(), nextHotshotBlock)
+		if err != nil {
+			log.Warn("unable to fetch header for hotshot block", "err", err)
+		} else {
+			s.PerfRecorder.SetStartTime(timestamp)
+			s.PerfRecorder.SetEndTime(blockProductionTime, fmt.Sprintf("Time duration between hotshot block %d and current block", nextHotshotBlock))
+		}
+	}
+}
+
+// Export this function only for testing purpose
+func (s *EspressoStreamer) SetSGXVerifier(sgxVerifier espressotee.EspressoSGXVerifierInterface) {
+	s.espressoSGXVerifier = sgxVerifier
+}
+
+func (s *EspressoStreamer) SetBatcherAddressesFetcher(fetcher func(l1Height uint64, address common.Address) (bool, error)) {
+	s.batcherAddressesFetcher = fetcher
+}
+
+func fetchNextHotshotBlock(
+	ctx context.Context,
+	espressoClient espressoClient.EspressoClient,
+	nextHotshotBlockNum uint64,
+	parseHotShotPayloadFn func(tx espressoTypes.Bytes, l1Height uint64) error,
+	namespace uint64,
+) (uint64, error) {
+
+	// get the current hotshot block
+	latestBlockHeight, err := espressoClient.FetchLatestBlockHeight(ctx)
+	if err != nil {
+		return 0, fmt.Errorf("%w: %w", ErrFailedToFetchTransactions, err)
+	}
+
+	fromBlock := nextHotshotBlockNum
+	toBlock := latestBlockHeight
+
+	if latestBlockHeight-nextHotshotBlockNum > HOTSHOT_RANGE_LIMIT {
+		toBlock = nextHotshotBlockNum + HOTSHOT_RANGE_LIMIT
+	}
+
+	// this means we have no blocks to process and we are all caught up
+	if fromBlock == toBlock {
+		return toBlock, nil
+	}
+
+	// here we are fetching transactions in range [fromBlock, toBlock) exclusive
+	//  by default FetchNamespaceTransactionsInRange is exclusive of the last element
+	namespaceTransactionRangeData, err := espressoClient.FetchNamespaceTransactionsInRange(ctx, fromBlock, toBlock, namespace)
+	if err != nil {
+		return 0, fmt.Errorf("%w: %w", ErrFailedToFetchTransactions, err)
+	}
+	if len(namespaceTransactionRangeData) == 0 {
+		// no transactions found in this range is a valid state (e.g., empty blocks), not an error
+		return toBlock, nil
+	}
+
+	// we are subtracting 1 here because FetchNamespaceTransactionsInRange is exclusive of the last element
+	header, err := espressoClient.FetchHeaderByHeight(ctx, toBlock-1)
+	l1Height := uint64(0)
+	if err != nil {
+		return 0, fmt.Errorf("%w: %w", ErrFailedToFetchTransactions, err)
+	}
+
+	finalized := header.Header.GetL1Finalized()
+	if finalized != nil {
+		l1Height = finalized.Number
+	}
+
+	for _, namespaceTransactionData := range namespaceTransactionRangeData {
+		for _, tx := range namespaceTransactionData.Transactions {
+			txPayloadBytes := tx.Payload
+			err := parseHotShotPayloadFn(txPayloadBytes, l1Height)
+			if err != nil && !strings.Contains(err.Error(), ErrRetryParsingHotShotPayload.Error()) {
+				log.Warn("failed to verify espresso transaction", "err", err)
+				continue
+			}
+			if err != nil {
+				return 0, err
+			}
+		}
+	}
+
+	return toBlock, nil
+}
+
+func (s *EspressoStreamer) Start(ctxIn context.Context) error {
+	s.StopWaiter.Start(ctxIn, s)
+
+	ephemeralErrorHandler := util.NewEphemeralErrorHandler(3*time.Minute, ErrFailedToFetchTransactions.Error(), 1*time.Minute)
+	block := s.nextHotshotBlockNum
+	err := s.CallIterativelySafe(func(ctx context.Context) time.Duration {
+		if s.nextHotshotBlockNum >= block+1000 {
+			log.Info("Now processing hotshot block", "block number", s.nextHotshotBlockNum)
+			block = s.nextHotshotBlockNum
+		} else {
+			log.Debug("Now processing hotshot block", "block number", s.nextHotshotBlockNum)
+		}
+		err := s.QueueMessagesFromHotshot(ctx, s.parseEspressoTransaction)
+		if err != nil {
+			logLevel := log.Error
+			logLevel = ephemeralErrorHandler.LogLevel(err, logLevel)
+			logLevel("error while queueing messages from hotshot", "err", err)
+			return s.retryTime
+		} else {
+			ephemeralErrorHandler.Reset()
+		}
+		return 0
+	})
+	return err
+}
+
+func (s *EspressoStreamer) StopAndWait() {
+	s.StopWaiter.StopAndWait()
+}
diff --git a/espressostreamer/espresso_streamer_test.go b/espressostreamer/espresso_streamer_test.go
new file mode 100644
index 00000000000..6cf59112e44
--- /dev/null
+++ b/espressostreamer/espresso_streamer_test.go
@@ -0,0 +1,387 @@
+package espressostreamer
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"testing"
+	"time"
+
+	espressoClient "github.com/EspressoSystems/espresso-network/sdks/go/client"
+	"github.com/EspressoSystems/espresso-network/sdks/go/types"
+	espressoTypes "github.com/EspressoSystems/espresso-network/sdks/go/types"
+	espressoCommon "github.com/EspressoSystems/espresso-network/sdks/go/types/common"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/rpc"
+
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+	"github.com/offchainlabs/nitro/arbutil"
+	"github.com/offchainlabs/nitro/espressotee"
+)
+
+func TestEspressoStreamer(t *testing.T) {
+	t.Run("Peek should not change the current position", func(t *testing.T) {
+		mockEspressoClient := new(mockEspressoClient)
+		mockEspressoTEEVerifierClient := new(mockEspressoTEEVerifier)
+
+		streamer := NewEspressoStreamer(1, 3, mockEspressoTEEVerifierClient, mockEspressoClient, false, func(l1Height uint64, addr common.Address) (bool, error) { return false, nil }, 1*time.Second)
+
+		streamer.Reset(1, 3)
+
+		before := streamer.currentMessagePos
+		r := streamer.Peek()
+		assert.Nil(t, r)
+		assert.Equal(t, before, streamer.currentMessagePos)
+
+		streamer.messageWithMetadataAndPos = map[uint64]*MessageWithMetadataAndPos{
+			1: {
+				MessageWithMeta: arbostypes.MessageWithMetadata{},
+				Pos:             1,
+				HotshotHeight:   3,
+			},
+			2: {
+				MessageWithMeta: arbostypes.MessageWithMetadata{},
+				Pos:             2,
+				HotshotHeight:   4,
+			},
+		}
+
+		r = streamer.Peek()
+		assert.Equal(t, streamer.messageWithMetadataAndPos[1], r)
+		assert.Equal(t, before, streamer.currentMessagePos)
+		assert.Equal(t, len(streamer.messageWithMetadataAndPos), 2)
+	})
+	t.Run("Next should consume a message if it is in buffer", func(t *testing.T) {
+		mockEspressoClient := new(mockEspressoClient)
+		mockEspressoTEEVerifierClient := new(mockEspressoTEEVerifier)
+
+		streamer := NewEspressoStreamer(1, 3, mockEspressoTEEVerifierClient, mockEspressoClient, false, func(l1Height uint64, addr common.Address) (bool, error) { return false, nil }, 1*time.Second)
+
+		streamer.Reset(1, 3)
+
+		// Empty buffer. Should not change anything
+		initialPos := streamer.currentMessagePos
+		r := streamer.Next()
+		assert.Nil(t, r)
+		assert.Equal(t, initialPos, streamer.currentMessagePos)
+
+		streamer.messageWithMetadataAndPos = map[uint64]*MessageWithMetadataAndPos{
+			1: {
+				MessageWithMeta: arbostypes.MessageWithMetadata{},
+				Pos:             1,
+				HotshotHeight:   3,
+			},
+			2: {
+				MessageWithMeta: arbostypes.MessageWithMetadata{},
+				Pos:             2,
+				HotshotHeight:   4,
+			},
+		}
+
+		expectedFirst := streamer.messageWithMetadataAndPos[initialPos]
+		r = streamer.Next()
+		assert.Equal(t, expectedFirst, r)
+		assert.Equal(t, initialPos+1, streamer.currentMessagePos)
+		// Next consumes the message, buffer now has 1 message.
+		assert.Equal(t, len(streamer.messageWithMetadataAndPos), 1)
+
+		// Second message
+		peekMessage := streamer.Peek()
+		assert.NotNil(t, peekMessage)
+		assert.Equal(t, initialPos+1, streamer.currentMessagePos)
+		assert.Equal(t, len(streamer.messageWithMetadataAndPos), 1)
+
+		newMessage := streamer.Next()
+		assert.Equal(t, peekMessage, newMessage)
+		assert.Equal(t, initialPos+2, streamer.currentMessagePos)
+
+		// Empty message should not alter the current position
+		third := streamer.Next()
+		assert.Nil(t, third)
+		assert.Equal(t, initialPos+2, streamer.currentMessagePos)
+	})
+	t.Run("Streamer should not skip any hotshot blocks", func(t *testing.T) {
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		mockEspressoClient := new(mockEspressoClient)
+		mockEspressoTEEVerifierClient := new(mockEspressoTEEVerifier)
+
+		namespace := uint64(1)
+
+		mockEspressoClient.On("FetchLatestBlockHeight", ctx).Return(uint64(4), nil).Once()
+		mockEspressoClient.On("FetchNamespaceTransactionsInRange", ctx, uint64(3), uint64(4), namespace).Return([]types.NamespaceTransactionsRangeData{}, nil).Once()
+		mockEspressoClient.On("FetchLatestBlockHeight", ctx).Return(uint64(5), nil).Once()
+		mockEspressoClient.On("FetchNamespaceTransactionsInRange", ctx, uint64(4), uint64(5), namespace).Return([]types.NamespaceTransactionsRangeData{}, nil).Once()
+		mockEspressoClient.On("FetchLatestBlockHeight", ctx).Return(uint64(6), nil).Once()
+		mockEspressoClient.On("FetchNamespaceTransactionsInRange", ctx, uint64(5), uint64(6), namespace).Return([]types.NamespaceTransactionsRangeData{}, nil).Once()
+		mockEspressoClient.On("FetchLatestBlockHeight", ctx).Return(uint64(7), nil).Once()
+		mockEspressoClient.On("FetchNamespaceTransactionsInRange", ctx, uint64(6), uint64(7), namespace).Return([]types.NamespaceTransactionsRangeData{}, errors.New("test error")).Once()
+
+		streamer := NewEspressoStreamer(namespace, 3, mockEspressoTEEVerifierClient, mockEspressoClient, false, func(l1Height uint64, addr common.Address) (bool, error) { return false, nil }, 1*time.Second)
+
+		testParseFn := func(tx types.Bytes, l1 uint64) error {
+			return nil
+		}
+
+		err := streamer.QueueMessagesFromHotshot(ctx, testParseFn)
+		require.NoError(t, err)
+		require.Equal(t, streamer.nextHotshotBlockNum, uint64(4))
+
+		err = streamer.QueueMessagesFromHotshot(ctx, testParseFn)
+		require.NoError(t, err)
+		require.Equal(t, streamer.nextHotshotBlockNum, uint64(5))
+
+		err = streamer.QueueMessagesFromHotshot(ctx, testParseFn)
+		require.NoError(t, err)
+		require.Equal(t, streamer.nextHotshotBlockNum, uint64(6))
+
+		err = streamer.QueueMessagesFromHotshot(ctx, testParseFn)
+		require.Error(t, err)
+		require.Equal(t, streamer.nextHotshotBlockNum, uint64(6))
+
+	})
+	t.Run("Streamer should query hotshot after being reset", func(t *testing.T) {
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+		mockEspressoClient := new(mockEspressoClient)
+		mockEspressoTEEVerifierClient := new(mockEspressoTEEVerifier)
+
+		namespace := uint64(1)
+		mockEspressoClient.On("FetchLatestBlockHeight", ctx).Return(uint64(4), nil).Once()
+		mockEspressoClient.On("FetchNamespaceTransactionsInRange", ctx, uint64(3), uint64(4), namespace).Return([]types.NamespaceTransactionsRangeData{
+			{
+				Transactions: []types.Transaction{
+					{
+						Namespace: 1,
+						Payload:   espressoTypes.Bytes{0x05, 0x06, 0x07, 0x08},
+					},
+				},
+			},
+		}, nil).Once()
+
+		mockEspressoClient.On("FetchLatestBlockHeight", ctx).Return(uint64(5), nil).Once()
+		mockEspressoClient.On("FetchNamespaceTransactionsInRange", ctx, uint64(4), uint64(5), namespace).Return([]types.NamespaceTransactionsRangeData{
+			{
+				Transactions: []types.Transaction{
+					{
+						Namespace: 1,
+						Payload:   espressoTypes.Bytes{0x05, 0x06, 0x07, 0x08},
+					},
+				},
+			},
+		}, nil).Once()
+
+		streamer := NewEspressoStreamer(namespace, 3, mockEspressoTEEVerifierClient, mockEspressoClient, false, func(l1Height uint64, addr common.Address) (bool, error) { return false, nil }, 1*time.Second)
+
+		testParseFn := func(pos uint64, hotshotheight uint64) func(tx types.Bytes, l1Height uint64) error {
+
+			return func(tx types.Bytes, l1Height uint64) error {
+				msg := &MessageWithMetadataAndPos{
+					MessageWithMeta: arbostypes.MessageWithMetadata{
+						Message: &arbostypes.L1IncomingMessage{},
+					},
+					Pos:           pos,
+					HotshotHeight: hotshotheight,
+				}
+				streamer.messageWithMetadataAndPos[msg.Pos] = msg
+				return nil
+			}
+		}
+
+		err := streamer.QueueMessagesFromHotshot(ctx, testParseFn(3, 3))
+		require.NoError(t, err)
+
+		err = streamer.QueueMessagesFromHotshot(ctx, testParseFn(4, 4))
+		require.NoError(t, err)
+
+		require.Equal(t, 2, len(streamer.messageWithMetadataAndPos))
+
+		streamer.Reset(0, 3)
+
+		require.Equal(t, 0, len(streamer.messageWithMetadataAndPos))
+
+		// Add new mocks for the next fetch after reset
+		mockEspressoClient.On("FetchLatestBlockHeight", ctx).Return(uint64(4), nil).Once()
+		mockEspressoClient.On("FetchNamespaceTransactionsInRange", ctx, uint64(3), uint64(4), namespace).Return([]types.NamespaceTransactionsRangeData{
+			{
+				Transactions: []types.Transaction{
+					{
+						Namespace: 1,
+						Payload:   espressoTypes.Bytes{0x05, 0x06, 0x07, 0x08},
+					},
+				},
+			},
+		}, nil).Once()
+
+		err = streamer.QueueMessagesFromHotshot(ctx, testParseFn(3, 3))
+		require.NoError(t, err)
+
+		require.Equal(t, len(streamer.messageWithMetadataAndPos), 1)
+	})
+
+	t.Run("rpc error should retry", func(t *testing.T) {
+		ctx := context.Background()
+		mockEspressoClient := new(mockEspressoClient)
+		namespace := uint64(1)
+		blockNum := uint64(3)
+
+		mockEspressoClient.On("FetchLatestBlockHeight", ctx).Return(blockNum+1, nil).Once()
+
+		tx1, tx2, tx3 := espressoTypes.Bytes{0x01}, espressoTypes.Bytes{0x02}, espressoTypes.Bytes{0x03}
+		mockEspressoClient.On("FetchNamespaceTransactionsInRange", ctx, blockNum, blockNum+1, namespace).Return([]types.NamespaceTransactionsRangeData{
+			{
+				Transactions: []types.Transaction{
+					{
+						Namespace: namespace,
+						Payload:   tx1,
+					},
+					{
+						Namespace: namespace,
+						Payload:   tx2,
+					},
+					{
+						Namespace: namespace,
+						Payload:   tx3,
+					},
+				},
+			},
+		}, nil).Once()
+
+		parseAttemptCount := 0
+		messages := []*MessageWithMetadataAndPos{}
+		parseFn := func(tx types.Bytes, _ uint64) error {
+			if assert.ObjectsAreEqual(tx, tx2) {
+				parseAttemptCount++
+				return rpc.ErrNoResult
+			}
+			messages = append(messages, &MessageWithMetadataAndPos{
+				MessageWithMeta: arbostypes.MessageWithMetadata{},
+				Pos:             uint64(tx[0]),
+				HotshotHeight:   blockNum,
+			})
+			return nil
+		}
+
+		_, err := fetchNextHotshotBlock(ctx, mockEspressoClient, blockNum, parseFn, namespace)
+		require.NoError(t, err)
+
+		require.Equal(t, 2, len(messages), "Expected to process two messages")
+		if len(messages) == 2 && len(tx1) > 0 && len(tx3) > 0 {
+			assert.Equal(t, uint64(tx1[0]), messages[0].Pos)
+			assert.Equal(t, uint64(tx3[0]), messages[1].Pos)
+		}
+
+		require.Equal(t, 1, parseAttemptCount, "Expected the failing transaction to be attempted only once")
+
+		mockEspressoClient.AssertExpectations(t)
+	})
+}
+
+// This serves to assert that we should be expecting a specific error during the test, and if the error does not match, fail the test.
+func ExpectErr(t *testing.T, err error, expectedError error) {
+	t.Helper()
+	if !errors.Is(err, expectedError) {
+		t.Fatal(err, expectedError)
+	}
+}
+
+// This test ensures that parseEspressoTransaction will have
+func TestEspressoEmptyTransaction(t *testing.T) {
+	mockEspressoClient := new(mockEspressoClient)
+	mockEspressoTEEVerifierClient := new(mockEspressoTEEVerifier)
+	streamer := NewEspressoStreamer(1, 1, mockEspressoTEEVerifierClient, mockEspressoClient, false, func(l1Height uint64, addr common.Address) (bool, error) { return false, nil }, time.Millisecond)
+	// This determines the contents of the message. For this test the contents of the message needs to be empty (not 0's) to properly test the behavior
+	msgFetcher := func(arbutil.MessageIndex) ([]byte, error) {
+		return []byte{}, nil
+	}
+	// create an empty payload
+	test := []arbutil.MessageIndex{1, 2}
+	payload, _ := arbutil.BuildRawHotShotPayload(test, msgFetcher, 100000) // this value is just a random number to get BuildRawHotShotPayload to return a payload
+	// create a fake signature for the payload.
+	signerFunc := func([]byte) ([]byte, error) {
+		return []byte{1}, nil
+	}
+	signedPayload, _ := arbutil.SignHotShotPayload(payload, signerFunc)
+	err := streamer.parseEspressoTransaction(signedPayload, 1)
+	ExpectErr(t, err, ErrPayloadHadNoMessages)
+}
+
+type mockEspressoTEEVerifier struct {
+	mock.Mock
+}
+
+var _ espressotee.EspressoSGXVerifierInterface = (*mockEspressoTEEVerifier)(nil)
+
+func (v *mockEspressoTEEVerifier) Verify(opts *bind.CallOpts, attestation []byte, signature [32]byte) (espressotee.EnclaveReport, error) {
+	return espressotee.EnclaveReport{}, nil
+}
+
+type mockEspressoClient struct {
+	mock.Mock
+}
+
+// StreamTransactions implements client.EspressoClient.
+func (m *mockEspressoClient) StreamTransactions(ctx context.Context, height uint64) (espressoClient.Stream[espressoTypes.TransactionQueryData], error) {
+	panic("unimplemented")
+}
+
+// StreamTransactionsInNamespace implements client.EspressoClient.
+func (m *mockEspressoClient) StreamTransactionsInNamespace(ctx context.Context, height uint64, namespace uint64) (espressoClient.Stream[espressoTypes.TransactionQueryData], error) {
+	panic("unimplemented")
+}
+
+func (m *mockEspressoClient) FetchLatestBlockHeight(ctx context.Context) (uint64, error) {
+	args := m.Called(ctx)
+	//nolint:errcheck
+	return args.Get(0).(uint64), args.Error(1)
+}
+
+func (m *mockEspressoClient) FetchExplorerTransactionByHash(ctx context.Context, hash *types.TaggedBase64) (types.ExplorerTransactionQueryData, error) {
+	args := m.Called(ctx, hash)
+	//nolint:errcheck
+	return args.Get(0).(types.ExplorerTransactionQueryData), args.Error(1)
+}
+
+// FetchNamespaceTransactionsInRange implements client.EspressoClient.
+func (m *mockEspressoClient) FetchNamespaceTransactionsInRange(ctx context.Context, fromHeight uint64, toHeight uint64, namespace uint64) ([]espressoTypes.NamespaceTransactionsRangeData, error) {
+	args := m.Called(ctx, fromHeight, toHeight, namespace)
+	//nolint:errcheck
+	return args.Get(0).([]espressoTypes.NamespaceTransactionsRangeData), args.Error(1)
+}
+
+func (m *mockEspressoClient) FetchTransactionsInBlock(ctx context.Context, blockHeight uint64, namespace uint64) (espressoClient.TransactionsInBlock, error) {
+	args := m.Called(ctx, blockHeight, namespace)
+	//nolint:errcheck
+	return args.Get(0).(espressoClient.TransactionsInBlock), args.Error(1)
+}
+
+func (m *mockEspressoClient) FetchHeaderByHeight(ctx context.Context, blockHeight uint64) (espressoTypes.HeaderImpl, error) {
+	header := espressoTypes.Header0_3{Height: blockHeight, L1Finalized: &espressoTypes.L1BlockInfo{Number: 1}}
+	return espressoTypes.HeaderImpl{Header: &header}, nil
+}
+
+func (m *mockEspressoClient) FetchHeadersByRange(ctx context.Context, from uint64, until uint64) ([]types.HeaderImpl, error) {
+	panic("not implemented")
+}
+
+func (m *mockEspressoClient) FetchRawHeaderByHeight(ctx context.Context, height uint64) (json.RawMessage, error) {
+	panic("not implemented")
+}
+
+func (m *mockEspressoClient) FetchTransactionByHash(ctx context.Context, hash *types.TaggedBase64) (types.TransactionQueryData, error) {
+	panic("not implemented")
+}
+
+func (m *mockEspressoClient) FetchVidCommonByHeight(ctx context.Context, blockHeight uint64) (types.VidCommon, error) {
+	panic("not implemented")
+}
+
+func (m *mockEspressoClient) SubmitTransaction(ctx context.Context, tx espressoCommon.Transaction) (*espressoCommon.TaggedBase64, error) {
+	panic("not implemented")
+}
diff --git a/espressostreamer/perf_recorder.go b/espressostreamer/perf_recorder.go
new file mode 100644
index 00000000000..138c1206769
--- /dev/null
+++ b/espressostreamer/perf_recorder.go
@@ -0,0 +1,26 @@
+package espressostreamer
+
+import (
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+)
+
+type PerfRecorder struct {
+	startTime time.Time
+	endTime   time.Time
+}
+
+func NewPerfRecorder() *PerfRecorder {
+	return &PerfRecorder{}
+}
+
+func (p *PerfRecorder) SetStartTime(time time.Time) {
+	p.startTime = time
+}
+
+func (p *PerfRecorder) SetEndTime(time time.Time, logMessage string) {
+	p.endTime = time
+	duration := p.endTime.Sub(p.startTime)
+	log.Debug(logMessage, "start time", p.startTime, "end time", p.endTime, "duration", duration)
+}
diff --git a/espressotee/espresso_tee_helpers.go b/espressotee/espresso_tee_helpers.go
new file mode 100644
index 00000000000..cfdd7be0161
--- /dev/null
+++ b/espressotee/espresso_tee_helpers.go
@@ -0,0 +1,128 @@
+package espressotee
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/offchainlabs/nitro/arbnode/dataposter"
+	"github.com/offchainlabs/nitro/espresso-tee-contracts/espressogen"
+)
+
+type TEE uint8
+
+const (
+	NITRO TEE = 0 // AWS Nitro
+
+	EMPTY TEE = 254
+	TESTS TEE = 2
+	// Define the empty string, which coudld be useful in certain circumstances
+	// Also define empty and test related contents at the end of the types range to make room
+	// for other sequential TEE types.
+)
+
+const (
+	EspressoMaxTxnWaitTime                = 3 * time.Minute
+	EspressoRetryReadContractDelay        = 5 * time.Second
+	EspressoMaxRetries                    = 5
+	EspressoGasLimitBufferIncreasePercent = 20
+)
+
+func FromString(s string) (TEE, error) {
+	switch strings.ToUpper(strings.TrimSpace(s)) {
+	case "NITRO":
+		return NITRO, nil
+	case "TESTS":
+		return TESTS, nil
+	case "":
+		return EMPTY, nil
+	default:
+		return 0, fmt.Errorf("invalid TEE type: %q", s)
+	}
+}
+
+type ContractVerificationFunc func() (bool, error)
+
+func ContractVerification(
+	fn ContractVerificationFunc,
+	msg string,
+) (bool, error) {
+	var err error
+	success := false
+	for attempt := 0; attempt < EspressoMaxRetries; attempt++ {
+		success, err = fn()
+		if err != nil {
+			log.Error(msg, "err", err)
+		}
+		if success {
+			return true, nil
+		}
+
+		if attempt < EspressoMaxRetries-1 {
+			log.Error(msg, "attempt", attempt, "retry delay", EspressoRetryReadContractDelay)
+			time.Sleep(EspressoRetryReadContractDelay)
+		}
+	}
+	return false, nil
+}
+
+/**
+ * This functions checks the dataposter nonce and the parent chains nonce
+ * If these two differ, dont send a transaction as registering the signer is costly and we dont want to send multiple transactions.
+ * This will constantly be called when we try and post a batch which will allow time for the two to eventually sync up.
+ */
+func NonceValidation(context context.Context, l1Client *ethclient.Client, dataPoster *dataposter.DataPoster) error {
+	nonce, err := l1Client.NonceAt(context, dataPoster.Sender(), nil)
+	if err != nil {
+		log.Warn("could not retrieve on-chain nonce", "err", err)
+		return err
+	}
+	dataPosterNonce, _, err := dataPoster.GetNextNonceAndMeta(context)
+	if err != nil {
+		log.Warn("error getting dataposter nonce", "err", err)
+		return err
+	}
+	log.Info("successfully got datapaster next nonce and on-chain nonce", "dataposter nonce", dataPosterNonce, "on-chain nonce", nonce)
+	if dataPosterNonce != nonce {
+		return fmt.Errorf("dataposter nonce %d does not match on-chain nonce %d", dataPosterNonce, nonce)
+	}
+	return nil
+}
+
+// EncodeNitroMockVerifierJournalPublicKey returns ABI-encoded VerifierJournal bytes
+// with only PublicKey set; Nitro mock ignores the rest of the fields.
+func EncodeNitroMockVerifierJournalPublicKey(publicKey []byte) ([]byte, error) {
+	journalType, err := abi.NewType("tuple", "VerifierJournal", []abi.ArgumentMarshaling{
+		{Name: "result", Type: "uint8"},
+		{Name: "trustedCertsPrefixLen", Type: "uint8"},
+		{Name: "timestamp", Type: "uint64"},
+		{Name: "certs", Type: "bytes32[]"},
+		{Name: "userData", Type: "bytes"},
+		{Name: "nonce", Type: "bytes"},
+		{Name: "publicKey", Type: "bytes"},
+		{Name: "pcrs", Type: "tuple[]", Components: []abi.ArgumentMarshaling{
+			{Name: "index", Type: "uint64"},
+			{Name: "value", Type: "tuple", Components: []abi.ArgumentMarshaling{
+				{Name: "first", Type: "bytes32"},
+				{Name: "second", Type: "bytes16"},
+			}},
+		}},
+		{Name: "moduleId", Type: "string"},
+	})
+	if err != nil {
+		return nil, err
+	}
+	args := abi.Arguments{{Type: journalType}}
+	return args.Pack(espressogen.VerifierJournal{
+		Certs:     [][32]byte{},
+		UserData:  []byte{},
+		Nonce:     []byte{},
+		PublicKey: publicKey,
+		Pcrs:      []espressogen.Pcr{},
+	})
+}
diff --git a/espressotee/espresso_tee_helpers_test.go b/espressotee/espresso_tee_helpers_test.go
new file mode 100644
index 00000000000..33dab664072
--- /dev/null
+++ b/espressotee/espresso_tee_helpers_test.go
@@ -0,0 +1,110 @@
+package espressotee
+
+import (
+	"context"
+	"errors"
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/rpc"
+
+	"github.com/offchainlabs/nitro/arbnode/dataposter"
+	"github.com/offchainlabs/nitro/util/headerreader"
+)
+
+type nonceStub struct {
+	nonce uint64
+}
+
+func (s *nonceStub) CallContext(_ context.Context, result interface{}, method string, _ ...interface{}) error {
+	switch method {
+	case "eth_getTransactionCount":
+		ptr, ok := result.(*hexutil.Uint64)
+		if !ok {
+			return errors.New("result is not a *hexutil.Uint64")
+		}
+		*ptr = hexutil.Uint64(s.nonce)
+	case "eth_getBlockByNumber":
+
+		ptr, ok := result.(**types.Header)
+		if !ok {
+			return errors.New("result is not a **types.Header")
+		}
+		*ptr = &types.Header{Number: big.NewInt(1)}
+	}
+	return nil
+}
+
+func (s *nonceStub) EthSubscribe(_ context.Context, _ interface{}, _ ...interface{}) (*rpc.ClientSubscription, error) {
+	return nil, nil
+}
+
+func (s *nonceStub) BatchCallContext(_ context.Context, _ []rpc.BatchElem) error {
+	return nil
+}
+
+func (s *nonceStub) Close() {}
+
+func buildDataPoster(t *testing.T, ctx context.Context, dataPosterNonce uint64, senderAddr common.Address) *dataposter.DataPoster {
+	t.Helper()
+
+	dpClient := ethclient.NewClient(&nonceStub{nonce: dataPosterNonce})
+
+	hr, err := headerreader.New(ctx, dpClient, func() *headerreader.Config {
+		cfg := headerreader.DefaultConfig
+		return &cfg
+	}, nil)
+	if err != nil {
+		t.Fatalf("failed to create header reader: %v", err)
+	}
+
+	testCfg := dataposter.TestDataPosterConfig
+	dp, err := dataposter.NewDataPoster(ctx, &dataposter.DataPosterOpts{
+		HeaderReader: hr,
+		Auth:         &bind.TransactOpts{From: senderAddr},
+		Config:       func() *dataposter.DataPosterConfig { return &testCfg },
+		MetadataRetriever: func(_ context.Context, _ *big.Int) ([]byte, error) {
+			return nil, nil
+		},
+		ParentChainID: big.NewInt(1337),
+	})
+	if err != nil {
+		t.Fatalf("failed to create data poster: %v", err)
+	}
+	return dp
+}
+
+// DataPoster reads nonce 5 from its stub; l1Client reports 6 — mismatch.
+func TestEspressoNonceValidationMismatch(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+	sender := common.HexToAddress("0xdeadbeef")
+
+	dp := buildDataPoster(t, ctx, 5, sender)
+	l1Client := ethclient.NewClient(&nonceStub{nonce: 6})
+
+	err := NonceValidation(ctx, l1Client, dp)
+	if err == nil {
+		t.Fatal("expected error for nonce mismatch, got nil")
+	}
+}
+
+// Both sides agree on nonce 5 — should pass.
+func TestEspressoNonceValidationMatch(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+	sender := common.HexToAddress("0xdeadbeef")
+
+	dp := buildDataPoster(t, ctx, 5, sender)
+	l1Client := ethclient.NewClient(&nonceStub{nonce: 5})
+
+	err := NonceValidation(ctx, l1Client, dp)
+	if err != nil {
+		t.Fatalf("expected no error for matching nonces, got: %v", err)
+	}
+}
diff --git a/espressotee/espresso_verifier.go b/espressotee/espresso_verifier.go
new file mode 100644
index 00000000000..cb004ecbc46
--- /dev/null
+++ b/espressotee/espresso_verifier.go
@@ -0,0 +1,192 @@
+package espressotee
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum"
+	"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/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/offchainlabs/nitro/arbnode/dataposter"
+	"github.com/offchainlabs/nitro/espresso-tee-contracts/espressogen"
+)
+
+type EspressoTEEVerifierInterface interface {
+	RegisterService(
+		dataPoster *dataposter.DataPoster,
+		attestation []byte,
+		data []byte,
+		teeType uint8,
+	) error
+	RegisteredServices(
+		signer common.Address,
+		teeType TEE,
+	) (bool, error)
+	EspressoTEEAddress() common.Address
+	ParentChainId() (uint64, error)
+	CheckNonceValidation(dataPoster *dataposter.DataPoster) error
+}
+
+type EspressoTEEVerifier struct {
+	espressoTEEVerifierAddress string
+	l1Client                   *ethclient.Client
+	address                    common.Address
+}
+
+var _ EspressoTEEVerifierInterface = (*EspressoTEEVerifier)(nil)
+
+func NewEspressoTEEVerifier(espressoTEEVerifierAddress string, l1Client *ethclient.Client, address common.Address) *EspressoTEEVerifier {
+
+	return &EspressoTEEVerifier{espressoTEEVerifierAddress: espressoTEEVerifierAddress, l1Client: l1Client, address: address}
+}
+func (e *EspressoTEEVerifier) RegisterService(
+	dataPoster *dataposter.DataPoster,
+	attestation []byte,
+	data []byte,
+	teeType uint8,
+) error {
+	var registrationErr error
+
+	for attempt := 0; attempt < EspressoMaxRetries; attempt++ {
+		registrationErr = e.registerService(
+			dataPoster,
+			attestation,
+			data,
+			teeType,
+		)
+
+		if registrationErr == nil {
+			return nil
+		}
+
+		log.Warn(
+			"service registration failed",
+			"err", registrationErr,
+			"attempt", attempt+1,
+		)
+		if attempt < EspressoMaxRetries-1 {
+			time.Sleep(EspressoRetryReadContractDelay)
+		}
+	}
+
+	return fmt.Errorf(
+		"service registration failed after %d attempts: %w",
+		EspressoMaxRetries,
+		registrationErr,
+	)
+}
+
+func (e *EspressoTEEVerifier) CheckNonceValidation(dataPoster *dataposter.DataPoster) error {
+	err := NonceValidation(context.Background(), e.l1Client, dataPoster)
+	if err != nil {
+		return fmt.Errorf("nonce validation failed: %w", err)
+	}
+	return nil
+}
+
+func (e *EspressoTEEVerifier) registerService(
+	dataPoster *dataposter.DataPoster,
+	attestation []byte,
+	data []byte,
+	teeType uint8,
+) error {
+	contractABI, err := espressogen.IEspressoTEEVerifierMetaData.GetAbi()
+	if err != nil {
+		return err
+	}
+
+	// Pack the function arguments (attestation, data, teeType)
+	calldata, err := contractABI.Pack("registerService", attestation, data, teeType)
+	if err != nil {
+		return err
+	}
+	msg := ethereum.CallMsg{
+		From:  dataPoster.Sender(),
+		To:    &e.address,
+		Data:  calldata,
+		Value: dataPoster.Auth().Value,
+	}
+
+	estimate, err := e.l1Client.EstimateGas(context.Background(), msg)
+	if err != nil {
+		return err
+	}
+
+	// Add a buffer to the estimate for the gas limit
+	gasLimit := estimate * (100 + EspressoGasLimitBufferIncreasePercent) / 100
+	log.Info("register signer gas limit", "gas limit", gasLimit)
+
+	// Since we use batch poster private key to register signer, we need to use dataposter to post transaction
+	// So the dataposter can track the proper nonce once we start posting batches
+	tx, err := dataPoster.PostSimpleTransaction(context.Background(), e.address, calldata, gasLimit, dataPoster.Auth().Value)
+	if err != nil {
+		log.Info("failed to post register signer transaction", "err", err)
+		return err
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), EspressoMaxTxnWaitTime)
+	defer cancel()
+	log.Info("waiting for register signer tx to be mined", "tx", tx.Hash().Hex(), "timeout", EspressoMaxTxnWaitTime)
+
+	receipt, err := bind.WaitMined(ctx, e.l1Client, tx)
+	if err != nil {
+		if ctx.Err() == context.DeadlineExceeded {
+			return fmt.Errorf(
+				"register signer timed out after %v minutes waiting for tx %s to be mined",
+				EspressoMaxTxnWaitTime,
+				tx.Hash().Hex(),
+			)
+		}
+		return err
+	}
+
+	if receipt.Status != types.ReceiptStatusSuccessful {
+		return errors.New("transaction failed")
+	}
+
+	log.Info("register signer tx succeeded", "tx", tx.Hash().Hex())
+
+	return nil
+}
+
+func (e *EspressoTEEVerifier) RegisteredServices(
+	signer common.Address,
+	teeType TEE,
+) (bool, error) {
+	return e.registeredServices(signer, teeType)
+}
+
+func (e *EspressoTEEVerifier) EspressoTEEAddress() common.Address {
+	return e.address
+}
+
+func (e *EspressoTEEVerifier) ParentChainId() (uint64, error) {
+	chainID, err := e.l1Client.ChainID(context.Background())
+	if err != nil {
+		return 0, err
+	}
+	return chainID.Uint64(), nil
+}
+
+func (e *EspressoTEEVerifier) registeredServices(address common.Address, teeType TEE) (bool, error) {
+	contract, err := espressogen.NewIEspressoTEEVerifier(e.address, e.l1Client)
+	if err != nil {
+		return false, err
+	}
+	ok, err := ContractVerification(
+		func() (bool, error) {
+			return contract.IsSignerValid(&bind.CallOpts{}, address, uint8(teeType))
+		},
+		"register services - address not yet registered in contract",
+	)
+	if err != nil {
+		return false, err
+	}
+	return ok, nil
+}
diff --git a/espressotee/legacy/espressogen.go b/espressotee/legacy/espressogen.go
new file mode 100644
index 00000000000..b932a8ce78a
--- /dev/null
+++ b/espressotee/legacy/espressogen.go
@@ -0,0 +1,70380 @@
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package legacy
+
+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
+	_ = abi.ConvertType
+)
+
+// EnclaveReport is an auto generated low-level Go binding around an user-defined struct.
+type EnclaveReport struct {
+	CpuSvn     [16]byte
+	MiscSelect [4]byte
+	Reserved1  [28]byte
+	Attributes [16]byte
+	MrEnclave  [32]byte
+	Reserved2  [32]byte
+	MrSigner   [32]byte
+	Reserved3  []byte
+	IsvProdId  uint16
+	IsvSvn     uint16
+	Reserved4  []byte
+	ReportData []byte
+}
+
+// Header is an auto generated low-level Go binding around an user-defined struct.
+type Header struct {
+	Version            uint16
+	AttestationKeyType [2]byte
+	TeeType            [4]byte
+	QeSvn              [2]byte
+	PceSvn             [2]byte
+	QeVendorId         [16]byte
+	UserData           [20]byte
+}
+
+// ICertManagerVerifiedCert is an auto generated low-level Go binding around an user-defined struct.
+type ICertManagerVerifiedCert struct {
+	Ca          bool
+	NotAfter    uint64
+	MaxPathLen  int64
+	SubjectHash [32]byte
+	PubKey      []byte
+}
+
+// IMulticall3Call is an auto generated low-level Go binding around an user-defined struct.
+type IMulticall3Call struct {
+	Target   common.Address
+	CallData []byte
+}
+
+// IMulticall3Call3 is an auto generated low-level Go binding around an user-defined struct.
+type IMulticall3Call3 struct {
+	Target       common.Address
+	AllowFailure bool
+	CallData     []byte
+}
+
+// IMulticall3Call3Value is an auto generated low-level Go binding around an user-defined struct.
+type IMulticall3Call3Value struct {
+	Target       common.Address
+	AllowFailure bool
+	Value        *big.Int
+	CallData     []byte
+}
+
+// IMulticall3Result is an auto generated low-level Go binding around an user-defined struct.
+type IMulticall3Result struct {
+	Success    bool
+	ReturnData []byte
+}
+
+// IdentityObj is an auto generated low-level Go binding around an user-defined struct.
+type IdentityObj struct {
+	Id                      uint8
+	Version                 uint32
+	IssueDateTimestamp      uint64
+	NextUpdateTimestamp     uint64
+	TcbEvaluationDataNumber uint32
+	Miscselect              [4]byte
+	MiscselectMask          [4]byte
+	Attributes              [16]byte
+	AttributesMask          [16]byte
+	Mrsigner                [32]byte
+	Isvprodid               uint16
+	Tcb                     []Tcb
+}
+
+// NitroValidatorPtrs is an auto generated low-level Go binding around an user-defined struct.
+type NitroValidatorPtrs struct {
+	ModuleID  *big.Int
+	Timestamp uint64
+	Digest    *big.Int
+	Pcrs      []*big.Int
+	Cert      *big.Int
+	Cabundle  []*big.Int
+	PublicKey *big.Int
+	UserData  *big.Int
+	Nonce     *big.Int
+}
+
+// StdInvariantFuzzArtifactSelector is an auto generated low-level Go binding around an user-defined struct.
+type StdInvariantFuzzArtifactSelector struct {
+	Artifact  string
+	Selectors [][4]byte
+}
+
+// StdInvariantFuzzInterface is an auto generated low-level Go binding around an user-defined struct.
+type StdInvariantFuzzInterface struct {
+	Addr      common.Address
+	Artifacts []string
+}
+
+// StdInvariantFuzzSelector is an auto generated low-level Go binding around an user-defined struct.
+type StdInvariantFuzzSelector struct {
+	Addr      common.Address
+	Selectors [][4]byte
+}
+
+// TCBLevelsObj is an auto generated low-level Go binding around an user-defined struct.
+type TCBLevelsObj struct {
+	Pcesvn              uint16
+	SgxComponentCpuSvns []uint8
+	TdxSvns             []uint8
+	TcbDateTimestamp    uint64
+	Status              uint8
+	AdvisoryIDs         []string
+}
+
+// TDXModule is an auto generated low-level Go binding around an user-defined struct.
+type TDXModule struct {
+	Mrsigner       []byte
+	Attributes     [8]byte
+	AttributesMask [8]byte
+}
+
+// TDXModuleIdentity is an auto generated low-level Go binding around an user-defined struct.
+type TDXModuleIdentity struct {
+	Id             string
+	Attributes     [8]byte
+	AttributesMask [8]byte
+	Mrsigner       []byte
+	TcbLevels      []TDXModuleTCBLevelsObj
+}
+
+// TDXModuleTCBLevelsObj is an auto generated low-level Go binding around an user-defined struct.
+type TDXModuleTCBLevelsObj struct {
+	Isvsvn           uint8
+	TcbDateTimestamp uint64
+	Status           uint8
+}
+
+// Tcb is an auto generated low-level Go binding around an user-defined struct.
+type Tcb struct {
+	Isvsvn        uint16
+	DateTimestamp *big.Int
+	Status        uint8
+}
+
+// TcbInfoBasic is an auto generated low-level Go binding around an user-defined struct.
+type TcbInfoBasic struct {
+	TcbType              uint8
+	Id                   uint8
+	Version              uint32
+	IssueDate            uint64
+	NextUpdate           uint64
+	EvaluationDataNumber uint32
+	Fmspc                [6]byte
+	Pceid                [2]byte
+}
+
+// VmSafeAccessListItem is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeAccessListItem struct {
+	Target      common.Address
+	StorageKeys [][32]byte
+}
+
+// VmSafeAccountAccess is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeAccountAccess struct {
+	ChainInfo       VmSafeChainInfo
+	Kind            uint8
+	Account         common.Address
+	Accessor        common.Address
+	Initialized     bool
+	OldBalance      *big.Int
+	NewBalance      *big.Int
+	DeployedCode    []byte
+	Value           *big.Int
+	Data            []byte
+	Reverted        bool
+	StorageAccesses []VmSafeStorageAccess
+	Depth           uint64
+}
+
+// VmSafeBroadcastTxSummary is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeBroadcastTxSummary struct {
+	TxHash          [32]byte
+	TxType          uint8
+	ContractAddress common.Address
+	BlockNumber     uint64
+	Success         bool
+}
+
+// VmSafeChainInfo is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeChainInfo struct {
+	ForkId  *big.Int
+	ChainId *big.Int
+}
+
+// VmSafeDebugStep is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeDebugStep struct {
+	Stack        []*big.Int
+	MemoryInput  []byte
+	Opcode       uint8
+	Depth        uint64
+	IsOutOfGas   bool
+	ContractAddr common.Address
+}
+
+// VmSafeDirEntry is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeDirEntry struct {
+	ErrorMessage string
+	Path         string
+	Depth        uint64
+	IsDir        bool
+	IsSymlink    bool
+}
+
+// VmSafeEthGetLogs is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeEthGetLogs struct {
+	Emitter          common.Address
+	Topics           [][32]byte
+	Data             []byte
+	BlockHash        [32]byte
+	BlockNumber      uint64
+	TransactionHash  [32]byte
+	TransactionIndex uint64
+	LogIndex         *big.Int
+	Removed          bool
+}
+
+// VmSafeFfiResult is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeFfiResult struct {
+	ExitCode int32
+	Stdout   []byte
+	Stderr   []byte
+}
+
+// VmSafeFsMetadata is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeFsMetadata struct {
+	IsDir     bool
+	IsSymlink bool
+	Length    *big.Int
+	ReadOnly  bool
+	Modified  *big.Int
+	Accessed  *big.Int
+	Created   *big.Int
+}
+
+// VmSafeGas is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeGas struct {
+	GasLimit      uint64
+	GasTotalUsed  uint64
+	GasMemoryUsed uint64
+	GasRefunded   int64
+	GasRemaining  uint64
+}
+
+// VmSafeLog is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeLog struct {
+	Topics  [][32]byte
+	Data    []byte
+	Emitter common.Address
+}
+
+// VmSafePotentialRevert is an auto generated low-level Go binding around an user-defined struct.
+type VmSafePotentialRevert struct {
+	Reverter     common.Address
+	PartialMatch bool
+	RevertData   []byte
+}
+
+// VmSafeRpc is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeRpc struct {
+	Key string
+	Url string
+}
+
+// VmSafeSignedDelegation is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeSignedDelegation struct {
+	V              uint8
+	R              [32]byte
+	S              [32]byte
+	Nonce          uint64
+	Implementation common.Address
+}
+
+// VmSafeStorageAccess is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeStorageAccess struct {
+	Account       common.Address
+	Slot          [32]byte
+	IsWrite       bool
+	PreviousValue [32]byte
+	NewValue      [32]byte
+	Reverted      bool
+}
+
+// VmSafeWallet is an auto generated low-level Go binding around an user-defined struct.
+type VmSafeWallet struct {
+	Addr       common.Address
+	PublicKeyX *big.Int
+	PublicKeyY *big.Int
+	PrivateKey *big.Int
+}
+
+// X509CRLObj is an auto generated low-level Go binding around an user-defined struct.
+type X509CRLObj struct {
+	SerialNumber         *big.Int
+	IssuerCommonName     string
+	ValidityNotBefore    *big.Int
+	ValidityNotAfter     *big.Int
+	SerialNumbersRevoked []*big.Int
+	Signature            []byte
+	Tbs                  []byte
+}
+
+// X509CertObj is an auto generated low-level Go binding around an user-defined struct.
+type X509CertObj struct {
+	SerialNumber      *big.Int
+	IssuerCommonName  string
+	ValidityNotBefore *big.Int
+	ValidityNotAfter  *big.Int
+	SubjectCommonName string
+	SubjectPublicKey  []byte
+	ExtensionPtr      *big.Int
+	Signature         []byte
+	Tbs               []byte
+}
+
+// Asn1DecodeMetaData contains all meta data concerning the Asn1Decode contract.
+var Asn1DecodeMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea264697066735822122080fa122466d4f64c2adb69ee5bb624667d6a219412d4e40e8d98dc77e0b0de0264736f6c63430008190033",
+}
+
+// Asn1DecodeABI is the input ABI used to generate the binding from.
+// Deprecated: Use Asn1DecodeMetaData.ABI instead.
+var Asn1DecodeABI = Asn1DecodeMetaData.ABI
+
+// Asn1DecodeBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use Asn1DecodeMetaData.Bin instead.
+var Asn1DecodeBin = Asn1DecodeMetaData.Bin
+
+// DeployAsn1Decode deploys a new Ethereum contract, binding an instance of Asn1Decode to it.
+func DeployAsn1Decode(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Asn1Decode, error) {
+	parsed, err := Asn1DecodeMetaData.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(Asn1DecodeBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &Asn1Decode{Asn1DecodeCaller: Asn1DecodeCaller{contract: contract}, Asn1DecodeTransactor: Asn1DecodeTransactor{contract: contract}, Asn1DecodeFilterer: Asn1DecodeFilterer{contract: contract}}, nil
+}
+
+// Asn1Decode is an auto generated Go binding around an Ethereum contract.
+type Asn1Decode struct {
+	Asn1DecodeCaller     // Read-only binding to the contract
+	Asn1DecodeTransactor // Write-only binding to the contract
+	Asn1DecodeFilterer   // Log filterer for contract events
+}
+
+// Asn1DecodeCaller is an auto generated read-only Go binding around an Ethereum contract.
+type Asn1DecodeCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Asn1DecodeTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type Asn1DecodeTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Asn1DecodeFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type Asn1DecodeFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Asn1DecodeSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type Asn1DecodeSession struct {
+	Contract     *Asn1Decode       // 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
+}
+
+// Asn1DecodeCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type Asn1DecodeCallerSession struct {
+	Contract *Asn1DecodeCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts     // Call options to use throughout this session
+}
+
+// Asn1DecodeTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type Asn1DecodeTransactorSession struct {
+	Contract     *Asn1DecodeTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
+}
+
+// Asn1DecodeRaw is an auto generated low-level Go binding around an Ethereum contract.
+type Asn1DecodeRaw struct {
+	Contract *Asn1Decode // Generic contract binding to access the raw methods on
+}
+
+// Asn1DecodeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type Asn1DecodeCallerRaw struct {
+	Contract *Asn1DecodeCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// Asn1DecodeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type Asn1DecodeTransactorRaw struct {
+	Contract *Asn1DecodeTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewAsn1Decode creates a new instance of Asn1Decode, bound to a specific deployed contract.
+func NewAsn1Decode(address common.Address, backend bind.ContractBackend) (*Asn1Decode, error) {
+	contract, err := bindAsn1Decode(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Asn1Decode{Asn1DecodeCaller: Asn1DecodeCaller{contract: contract}, Asn1DecodeTransactor: Asn1DecodeTransactor{contract: contract}, Asn1DecodeFilterer: Asn1DecodeFilterer{contract: contract}}, nil
+}
+
+// NewAsn1DecodeCaller creates a new read-only instance of Asn1Decode, bound to a specific deployed contract.
+func NewAsn1DecodeCaller(address common.Address, caller bind.ContractCaller) (*Asn1DecodeCaller, error) {
+	contract, err := bindAsn1Decode(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &Asn1DecodeCaller{contract: contract}, nil
+}
+
+// NewAsn1DecodeTransactor creates a new write-only instance of Asn1Decode, bound to a specific deployed contract.
+func NewAsn1DecodeTransactor(address common.Address, transactor bind.ContractTransactor) (*Asn1DecodeTransactor, error) {
+	contract, err := bindAsn1Decode(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &Asn1DecodeTransactor{contract: contract}, nil
+}
+
+// NewAsn1DecodeFilterer creates a new log filterer instance of Asn1Decode, bound to a specific deployed contract.
+func NewAsn1DecodeFilterer(address common.Address, filterer bind.ContractFilterer) (*Asn1DecodeFilterer, error) {
+	contract, err := bindAsn1Decode(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &Asn1DecodeFilterer{contract: contract}, nil
+}
+
+// bindAsn1Decode binds a generic wrapper to an already deployed contract.
+func bindAsn1Decode(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := Asn1DecodeMetaData.GetAbi()
+	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 (_Asn1Decode *Asn1DecodeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Asn1Decode.Contract.Asn1DecodeCaller.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 (_Asn1Decode *Asn1DecodeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Asn1Decode.Contract.Asn1DecodeTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Asn1Decode *Asn1DecodeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Asn1Decode.Contract.Asn1DecodeTransactor.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 (_Asn1Decode *Asn1DecodeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Asn1Decode.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 (_Asn1Decode *Asn1DecodeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Asn1Decode.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Asn1Decode *Asn1DecodeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Asn1Decode.Contract.contract.Transact(opts, method, params...)
+}
+
+// BELEMetaData contains all meta data concerning the BELE contract.
+var BELEMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212209abb3f0a6ef8c4f6b93aec5dd9648e05bb4e88c3dba3eba19e32ea4720c20b6e64736f6c63430008190033",
+}
+
+// BELEABI is the input ABI used to generate the binding from.
+// Deprecated: Use BELEMetaData.ABI instead.
+var BELEABI = BELEMetaData.ABI
+
+// BELEBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use BELEMetaData.Bin instead.
+var BELEBin = BELEMetaData.Bin
+
+// DeployBELE deploys a new Ethereum contract, binding an instance of BELE to it.
+func DeployBELE(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *BELE, error) {
+	parsed, err := BELEMetaData.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(BELEBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &BELE{BELECaller: BELECaller{contract: contract}, BELETransactor: BELETransactor{contract: contract}, BELEFilterer: BELEFilterer{contract: contract}}, nil
+}
+
+// BELE is an auto generated Go binding around an Ethereum contract.
+type BELE struct {
+	BELECaller     // Read-only binding to the contract
+	BELETransactor // Write-only binding to the contract
+	BELEFilterer   // Log filterer for contract events
+}
+
+// BELECaller is an auto generated read-only Go binding around an Ethereum contract.
+type BELECaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// BELETransactor is an auto generated write-only Go binding around an Ethereum contract.
+type BELETransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// BELEFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type BELEFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// BELESession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type BELESession struct {
+	Contract     *BELE             // 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
+}
+
+// BELECallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type BELECallerSession struct {
+	Contract *BELECaller   // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts // Call options to use throughout this session
+}
+
+// BELETransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type BELETransactorSession struct {
+	Contract     *BELETransactor   // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// BELERaw is an auto generated low-level Go binding around an Ethereum contract.
+type BELERaw struct {
+	Contract *BELE // Generic contract binding to access the raw methods on
+}
+
+// BELECallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type BELECallerRaw struct {
+	Contract *BELECaller // Generic read-only contract binding to access the raw methods on
+}
+
+// BELETransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type BELETransactorRaw struct {
+	Contract *BELETransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewBELE creates a new instance of BELE, bound to a specific deployed contract.
+func NewBELE(address common.Address, backend bind.ContractBackend) (*BELE, error) {
+	contract, err := bindBELE(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &BELE{BELECaller: BELECaller{contract: contract}, BELETransactor: BELETransactor{contract: contract}, BELEFilterer: BELEFilterer{contract: contract}}, nil
+}
+
+// NewBELECaller creates a new read-only instance of BELE, bound to a specific deployed contract.
+func NewBELECaller(address common.Address, caller bind.ContractCaller) (*BELECaller, error) {
+	contract, err := bindBELE(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &BELECaller{contract: contract}, nil
+}
+
+// NewBELETransactor creates a new write-only instance of BELE, bound to a specific deployed contract.
+func NewBELETransactor(address common.Address, transactor bind.ContractTransactor) (*BELETransactor, error) {
+	contract, err := bindBELE(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &BELETransactor{contract: contract}, nil
+}
+
+// NewBELEFilterer creates a new log filterer instance of BELE, bound to a specific deployed contract.
+func NewBELEFilterer(address common.Address, filterer bind.ContractFilterer) (*BELEFilterer, error) {
+	contract, err := bindBELE(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &BELEFilterer{contract: contract}, nil
+}
+
+// bindBELE binds a generic wrapper to an already deployed contract.
+func bindBELE(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := BELEMetaData.GetAbi()
+	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 (_BELE *BELERaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _BELE.Contract.BELECaller.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 (_BELE *BELERaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _BELE.Contract.BELETransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_BELE *BELERaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _BELE.Contract.BELETransactor.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 (_BELE *BELECallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _BELE.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 (_BELE *BELETransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _BELE.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_BELE *BELETransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _BELE.Contract.contract.Transact(opts, method, params...)
+}
+
+// Base64MetaData contains all meta data concerning the Base64 contract.
+var Base64MetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220f407ac176d109ebc020defc287f08949a84cfb7e79b061c452bac3802fb71ccb64736f6c63430008190033",
+}
+
+// Base64ABI is the input ABI used to generate the binding from.
+// Deprecated: Use Base64MetaData.ABI instead.
+var Base64ABI = Base64MetaData.ABI
+
+// Base64Bin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use Base64MetaData.Bin instead.
+var Base64Bin = Base64MetaData.Bin
+
+// DeployBase64 deploys a new Ethereum contract, binding an instance of Base64 to it.
+func DeployBase64(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Base64, error) {
+	parsed, err := Base64MetaData.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(Base64Bin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &Base64{Base64Caller: Base64Caller{contract: contract}, Base64Transactor: Base64Transactor{contract: contract}, Base64Filterer: Base64Filterer{contract: contract}}, nil
+}
+
+// Base64 is an auto generated Go binding around an Ethereum contract.
+type Base64 struct {
+	Base64Caller     // Read-only binding to the contract
+	Base64Transactor // Write-only binding to the contract
+	Base64Filterer   // Log filterer for contract events
+}
+
+// Base64Caller is an auto generated read-only Go binding around an Ethereum contract.
+type Base64Caller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Base64Transactor is an auto generated write-only Go binding around an Ethereum contract.
+type Base64Transactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Base64Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type Base64Filterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Base64Session is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type Base64Session struct {
+	Contract     *Base64           // 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
+}
+
+// Base64CallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type Base64CallerSession struct {
+	Contract *Base64Caller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts // Call options to use throughout this session
+}
+
+// Base64TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type Base64TransactorSession struct {
+	Contract     *Base64Transactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// Base64Raw is an auto generated low-level Go binding around an Ethereum contract.
+type Base64Raw struct {
+	Contract *Base64 // Generic contract binding to access the raw methods on
+}
+
+// Base64CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type Base64CallerRaw struct {
+	Contract *Base64Caller // Generic read-only contract binding to access the raw methods on
+}
+
+// Base64TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type Base64TransactorRaw struct {
+	Contract *Base64Transactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewBase64 creates a new instance of Base64, bound to a specific deployed contract.
+func NewBase64(address common.Address, backend bind.ContractBackend) (*Base64, error) {
+	contract, err := bindBase64(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Base64{Base64Caller: Base64Caller{contract: contract}, Base64Transactor: Base64Transactor{contract: contract}, Base64Filterer: Base64Filterer{contract: contract}}, nil
+}
+
+// NewBase64Caller creates a new read-only instance of Base64, bound to a specific deployed contract.
+func NewBase64Caller(address common.Address, caller bind.ContractCaller) (*Base64Caller, error) {
+	contract, err := bindBase64(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &Base64Caller{contract: contract}, nil
+}
+
+// NewBase64Transactor creates a new write-only instance of Base64, bound to a specific deployed contract.
+func NewBase64Transactor(address common.Address, transactor bind.ContractTransactor) (*Base64Transactor, error) {
+	contract, err := bindBase64(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &Base64Transactor{contract: contract}, nil
+}
+
+// NewBase64Filterer creates a new log filterer instance of Base64, bound to a specific deployed contract.
+func NewBase64Filterer(address common.Address, filterer bind.ContractFilterer) (*Base64Filterer, error) {
+	contract, err := bindBase64(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &Base64Filterer{contract: contract}, nil
+}
+
+// bindBase64 binds a generic wrapper to an already deployed contract.
+func bindBase64(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := Base64MetaData.GetAbi()
+	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 (_Base64 *Base64Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Base64.Contract.Base64Caller.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 (_Base64 *Base64Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Base64.Contract.Base64Transactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Base64 *Base64Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Base64.Contract.Base64Transactor.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 (_Base64 *Base64CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Base64.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 (_Base64 *Base64TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Base64.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Base64 *Base64TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Base64.Contract.contract.Transact(opts, method, params...)
+}
+
+// BytesUtilsMetaData contains all meta data concerning the BytesUtils contract.
+var BytesUtilsMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212205cd2743ccbb5ab4728ef3d2854ff0b1cc33eae2b87ba3f70f5137061f1aa007a64736f6c63430008190033",
+}
+
+// BytesUtilsABI is the input ABI used to generate the binding from.
+// Deprecated: Use BytesUtilsMetaData.ABI instead.
+var BytesUtilsABI = BytesUtilsMetaData.ABI
+
+// BytesUtilsBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use BytesUtilsMetaData.Bin instead.
+var BytesUtilsBin = BytesUtilsMetaData.Bin
+
+// DeployBytesUtils deploys a new Ethereum contract, binding an instance of BytesUtils to it.
+func DeployBytesUtils(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *BytesUtils, error) {
+	parsed, err := BytesUtilsMetaData.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(BytesUtilsBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &BytesUtils{BytesUtilsCaller: BytesUtilsCaller{contract: contract}, BytesUtilsTransactor: BytesUtilsTransactor{contract: contract}, BytesUtilsFilterer: BytesUtilsFilterer{contract: contract}}, nil
+}
+
+// BytesUtils is an auto generated Go binding around an Ethereum contract.
+type BytesUtils struct {
+	BytesUtilsCaller     // Read-only binding to the contract
+	BytesUtilsTransactor // Write-only binding to the contract
+	BytesUtilsFilterer   // Log filterer for contract events
+}
+
+// BytesUtilsCaller is an auto generated read-only Go binding around an Ethereum contract.
+type BytesUtilsCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// BytesUtilsTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type BytesUtilsTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// BytesUtilsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type BytesUtilsFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// BytesUtilsSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type BytesUtilsSession struct {
+	Contract     *BytesUtils       // 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
+}
+
+// BytesUtilsCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type BytesUtilsCallerSession struct {
+	Contract *BytesUtilsCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts     // Call options to use throughout this session
+}
+
+// BytesUtilsTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type BytesUtilsTransactorSession struct {
+	Contract     *BytesUtilsTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
+}
+
+// BytesUtilsRaw is an auto generated low-level Go binding around an Ethereum contract.
+type BytesUtilsRaw struct {
+	Contract *BytesUtils // Generic contract binding to access the raw methods on
+}
+
+// BytesUtilsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type BytesUtilsCallerRaw struct {
+	Contract *BytesUtilsCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// BytesUtilsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type BytesUtilsTransactorRaw struct {
+	Contract *BytesUtilsTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewBytesUtils creates a new instance of BytesUtils, bound to a specific deployed contract.
+func NewBytesUtils(address common.Address, backend bind.ContractBackend) (*BytesUtils, error) {
+	contract, err := bindBytesUtils(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &BytesUtils{BytesUtilsCaller: BytesUtilsCaller{contract: contract}, BytesUtilsTransactor: BytesUtilsTransactor{contract: contract}, BytesUtilsFilterer: BytesUtilsFilterer{contract: contract}}, nil
+}
+
+// NewBytesUtilsCaller creates a new read-only instance of BytesUtils, bound to a specific deployed contract.
+func NewBytesUtilsCaller(address common.Address, caller bind.ContractCaller) (*BytesUtilsCaller, error) {
+	contract, err := bindBytesUtils(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &BytesUtilsCaller{contract: contract}, nil
+}
+
+// NewBytesUtilsTransactor creates a new write-only instance of BytesUtils, bound to a specific deployed contract.
+func NewBytesUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*BytesUtilsTransactor, error) {
+	contract, err := bindBytesUtils(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &BytesUtilsTransactor{contract: contract}, nil
+}
+
+// NewBytesUtilsFilterer creates a new log filterer instance of BytesUtils, bound to a specific deployed contract.
+func NewBytesUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*BytesUtilsFilterer, error) {
+	contract, err := bindBytesUtils(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &BytesUtilsFilterer{contract: contract}, nil
+}
+
+// bindBytesUtils binds a generic wrapper to an already deployed contract.
+func bindBytesUtils(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := BytesUtilsMetaData.GetAbi()
+	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 (_BytesUtils *BytesUtilsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _BytesUtils.Contract.BytesUtilsCaller.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 (_BytesUtils *BytesUtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _BytesUtils.Contract.BytesUtilsTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_BytesUtils *BytesUtilsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _BytesUtils.Contract.BytesUtilsTransactor.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 (_BytesUtils *BytesUtilsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _BytesUtils.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 (_BytesUtils *BytesUtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _BytesUtils.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_BytesUtils *BytesUtilsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _BytesUtils.Contract.contract.Transact(opts, method, params...)
+}
+
+// CborDecodeMetaData contains all meta data concerning the CborDecode contract.
+var CborDecodeMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220e75fd70e21ea211a262597004b3355e96c82d372a4121d3feea8a5b45c841aba64736f6c63430008190033",
+}
+
+// CborDecodeABI is the input ABI used to generate the binding from.
+// Deprecated: Use CborDecodeMetaData.ABI instead.
+var CborDecodeABI = CborDecodeMetaData.ABI
+
+// CborDecodeBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use CborDecodeMetaData.Bin instead.
+var CborDecodeBin = CborDecodeMetaData.Bin
+
+// DeployCborDecode deploys a new Ethereum contract, binding an instance of CborDecode to it.
+func DeployCborDecode(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *CborDecode, error) {
+	parsed, err := CborDecodeMetaData.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(CborDecodeBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &CborDecode{CborDecodeCaller: CborDecodeCaller{contract: contract}, CborDecodeTransactor: CborDecodeTransactor{contract: contract}, CborDecodeFilterer: CborDecodeFilterer{contract: contract}}, nil
+}
+
+// CborDecode is an auto generated Go binding around an Ethereum contract.
+type CborDecode struct {
+	CborDecodeCaller     // Read-only binding to the contract
+	CborDecodeTransactor // Write-only binding to the contract
+	CborDecodeFilterer   // Log filterer for contract events
+}
+
+// CborDecodeCaller is an auto generated read-only Go binding around an Ethereum contract.
+type CborDecodeCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// CborDecodeTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type CborDecodeTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// CborDecodeFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type CborDecodeFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// CborDecodeSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type CborDecodeSession struct {
+	Contract     *CborDecode       // 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
+}
+
+// CborDecodeCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type CborDecodeCallerSession struct {
+	Contract *CborDecodeCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts     // Call options to use throughout this session
+}
+
+// CborDecodeTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type CborDecodeTransactorSession struct {
+	Contract     *CborDecodeTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
+}
+
+// CborDecodeRaw is an auto generated low-level Go binding around an Ethereum contract.
+type CborDecodeRaw struct {
+	Contract *CborDecode // Generic contract binding to access the raw methods on
+}
+
+// CborDecodeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type CborDecodeCallerRaw struct {
+	Contract *CborDecodeCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// CborDecodeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type CborDecodeTransactorRaw struct {
+	Contract *CborDecodeTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewCborDecode creates a new instance of CborDecode, bound to a specific deployed contract.
+func NewCborDecode(address common.Address, backend bind.ContractBackend) (*CborDecode, error) {
+	contract, err := bindCborDecode(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &CborDecode{CborDecodeCaller: CborDecodeCaller{contract: contract}, CborDecodeTransactor: CborDecodeTransactor{contract: contract}, CborDecodeFilterer: CborDecodeFilterer{contract: contract}}, nil
+}
+
+// NewCborDecodeCaller creates a new read-only instance of CborDecode, bound to a specific deployed contract.
+func NewCborDecodeCaller(address common.Address, caller bind.ContractCaller) (*CborDecodeCaller, error) {
+	contract, err := bindCborDecode(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &CborDecodeCaller{contract: contract}, nil
+}
+
+// NewCborDecodeTransactor creates a new write-only instance of CborDecode, bound to a specific deployed contract.
+func NewCborDecodeTransactor(address common.Address, transactor bind.ContractTransactor) (*CborDecodeTransactor, error) {
+	contract, err := bindCborDecode(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &CborDecodeTransactor{contract: contract}, nil
+}
+
+// NewCborDecodeFilterer creates a new log filterer instance of CborDecode, bound to a specific deployed contract.
+func NewCborDecodeFilterer(address common.Address, filterer bind.ContractFilterer) (*CborDecodeFilterer, error) {
+	contract, err := bindCborDecode(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &CborDecodeFilterer{contract: contract}, nil
+}
+
+// bindCborDecode binds a generic wrapper to an already deployed contract.
+func bindCborDecode(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := CborDecodeMetaData.GetAbi()
+	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 (_CborDecode *CborDecodeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _CborDecode.Contract.CborDecodeCaller.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 (_CborDecode *CborDecodeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _CborDecode.Contract.CborDecodeTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_CborDecode *CborDecodeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _CborDecode.Contract.CborDecodeTransactor.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 (_CborDecode *CborDecodeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _CborDecode.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 (_CborDecode *CborDecodeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _CborDecode.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_CborDecode *CborDecodeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _CborDecode.Contract.contract.Transact(opts, method, params...)
+}
+
+// CertManagerMetaData contains all meta data concerning the CertManager contract.
+var CertManagerMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"BASIC_CONSTRAINTS_OID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CERT_ALGO_OID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"EC_PUB_KEY_OID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"KEY_USAGE_OID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROOT_CA_CERT_HASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROOT_CA_CERT_MAX_PATH_LEN\",\"outputs\":[{\"internalType\":\"int64\",\"name\":\"\",\"type\":\"int64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROOT_CA_CERT_NOT_AFTER\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROOT_CA_CERT_PUB_KEY\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROOT_CA_CERT_SUBJECT_HASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SECP_384_R1_OID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"verified\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"cert\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"parentCertHash\",\"type\":\"bytes32\"}],\"name\":\"verifyCACert\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"cert\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"parentCertHash\",\"type\":\"bytes32\"}],\"name\":\"verifyClientCert\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"ca\",\"type\":\"bool\"},{\"internalType\":\"uint64\",\"name\":\"notAfter\",\"type\":\"uint64\"},{\"internalType\":\"int64\",\"name\":\"maxPathLen\",\"type\":\"int64\"},{\"internalType\":\"bytes32\",\"name\":\"subjectHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"pubKey\",\"type\":\"bytes\"}],\"internalType\":\"structICertManager.VerifiedCert\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"certHash\",\"type\":\"bytes32\"}],\"name\":\"CertVerified\",\"type\":\"event\"}]",
+	Bin: "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",
+}
+
+// CertManagerABI is the input ABI used to generate the binding from.
+// Deprecated: Use CertManagerMetaData.ABI instead.
+var CertManagerABI = CertManagerMetaData.ABI
+
+// CertManagerBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use CertManagerMetaData.Bin instead.
+var CertManagerBin = CertManagerMetaData.Bin
+
+// DeployCertManager deploys a new Ethereum contract, binding an instance of CertManager to it.
+func DeployCertManager(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *CertManager, error) {
+	parsed, err := CertManagerMetaData.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(CertManagerBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &CertManager{CertManagerCaller: CertManagerCaller{contract: contract}, CertManagerTransactor: CertManagerTransactor{contract: contract}, CertManagerFilterer: CertManagerFilterer{contract: contract}}, nil
+}
+
+// CertManager is an auto generated Go binding around an Ethereum contract.
+type CertManager struct {
+	CertManagerCaller     // Read-only binding to the contract
+	CertManagerTransactor // Write-only binding to the contract
+	CertManagerFilterer   // Log filterer for contract events
+}
+
+// CertManagerCaller is an auto generated read-only Go binding around an Ethereum contract.
+type CertManagerCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// CertManagerTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type CertManagerTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// CertManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type CertManagerFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// CertManagerSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type CertManagerSession struct {
+	Contract     *CertManager      // 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
+}
+
+// CertManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type CertManagerCallerSession struct {
+	Contract *CertManagerCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts      // Call options to use throughout this session
+}
+
+// CertManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type CertManagerTransactorSession struct {
+	Contract     *CertManagerTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts      // Transaction auth options to use throughout this session
+}
+
+// CertManagerRaw is an auto generated low-level Go binding around an Ethereum contract.
+type CertManagerRaw struct {
+	Contract *CertManager // Generic contract binding to access the raw methods on
+}
+
+// CertManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type CertManagerCallerRaw struct {
+	Contract *CertManagerCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// CertManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type CertManagerTransactorRaw struct {
+	Contract *CertManagerTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewCertManager creates a new instance of CertManager, bound to a specific deployed contract.
+func NewCertManager(address common.Address, backend bind.ContractBackend) (*CertManager, error) {
+	contract, err := bindCertManager(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &CertManager{CertManagerCaller: CertManagerCaller{contract: contract}, CertManagerTransactor: CertManagerTransactor{contract: contract}, CertManagerFilterer: CertManagerFilterer{contract: contract}}, nil
+}
+
+// NewCertManagerCaller creates a new read-only instance of CertManager, bound to a specific deployed contract.
+func NewCertManagerCaller(address common.Address, caller bind.ContractCaller) (*CertManagerCaller, error) {
+	contract, err := bindCertManager(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &CertManagerCaller{contract: contract}, nil
+}
+
+// NewCertManagerTransactor creates a new write-only instance of CertManager, bound to a specific deployed contract.
+func NewCertManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*CertManagerTransactor, error) {
+	contract, err := bindCertManager(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &CertManagerTransactor{contract: contract}, nil
+}
+
+// NewCertManagerFilterer creates a new log filterer instance of CertManager, bound to a specific deployed contract.
+func NewCertManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*CertManagerFilterer, error) {
+	contract, err := bindCertManager(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &CertManagerFilterer{contract: contract}, nil
+}
+
+// bindCertManager binds a generic wrapper to an already deployed contract.
+func bindCertManager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := CertManagerMetaData.GetAbi()
+	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 (_CertManager *CertManagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _CertManager.Contract.CertManagerCaller.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 (_CertManager *CertManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _CertManager.Contract.CertManagerTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_CertManager *CertManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _CertManager.Contract.CertManagerTransactor.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 (_CertManager *CertManagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _CertManager.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 (_CertManager *CertManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _CertManager.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_CertManager *CertManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _CertManager.Contract.contract.Transact(opts, method, params...)
+}
+
+// BASICCONSTRAINTSOID is a free data retrieval call binding the contract method 0x4519a352.
+//
+// Solidity: function BASIC_CONSTRAINTS_OID() view returns(bytes32)
+func (_CertManager *CertManagerCaller) BASICCONSTRAINTSOID(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _CertManager.contract.Call(opts, &out, "BASIC_CONSTRAINTS_OID")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// BASICCONSTRAINTSOID is a free data retrieval call binding the contract method 0x4519a352.
+//
+// Solidity: function BASIC_CONSTRAINTS_OID() view returns(bytes32)
+func (_CertManager *CertManagerSession) BASICCONSTRAINTSOID() ([32]byte, error) {
+	return _CertManager.Contract.BASICCONSTRAINTSOID(&_CertManager.CallOpts)
+}
+
+// BASICCONSTRAINTSOID is a free data retrieval call binding the contract method 0x4519a352.
+//
+// Solidity: function BASIC_CONSTRAINTS_OID() view returns(bytes32)
+func (_CertManager *CertManagerCallerSession) BASICCONSTRAINTSOID() ([32]byte, error) {
+	return _CertManager.Contract.BASICCONSTRAINTSOID(&_CertManager.CallOpts)
+}
+
+// CERTALGOOID is a free data retrieval call binding the contract method 0xaf9bdbc2.
+//
+// Solidity: function CERT_ALGO_OID() view returns(bytes32)
+func (_CertManager *CertManagerCaller) CERTALGOOID(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _CertManager.contract.Call(opts, &out, "CERT_ALGO_OID")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// CERTALGOOID is a free data retrieval call binding the contract method 0xaf9bdbc2.
+//
+// Solidity: function CERT_ALGO_OID() view returns(bytes32)
+func (_CertManager *CertManagerSession) CERTALGOOID() ([32]byte, error) {
+	return _CertManager.Contract.CERTALGOOID(&_CertManager.CallOpts)
+}
+
+// CERTALGOOID is a free data retrieval call binding the contract method 0xaf9bdbc2.
+//
+// Solidity: function CERT_ALGO_OID() view returns(bytes32)
+func (_CertManager *CertManagerCallerSession) CERTALGOOID() ([32]byte, error) {
+	return _CertManager.Contract.CERTALGOOID(&_CertManager.CallOpts)
+}
+
+// ECPUBKEYOID is a free data retrieval call binding the contract method 0xf69a82fe.
+//
+// Solidity: function EC_PUB_KEY_OID() view returns(bytes32)
+func (_CertManager *CertManagerCaller) ECPUBKEYOID(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _CertManager.contract.Call(opts, &out, "EC_PUB_KEY_OID")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// ECPUBKEYOID is a free data retrieval call binding the contract method 0xf69a82fe.
+//
+// Solidity: function EC_PUB_KEY_OID() view returns(bytes32)
+func (_CertManager *CertManagerSession) ECPUBKEYOID() ([32]byte, error) {
+	return _CertManager.Contract.ECPUBKEYOID(&_CertManager.CallOpts)
+}
+
+// ECPUBKEYOID is a free data retrieval call binding the contract method 0xf69a82fe.
+//
+// Solidity: function EC_PUB_KEY_OID() view returns(bytes32)
+func (_CertManager *CertManagerCallerSession) ECPUBKEYOID() ([32]byte, error) {
+	return _CertManager.Contract.ECPUBKEYOID(&_CertManager.CallOpts)
+}
+
+// KEYUSAGEOID is a free data retrieval call binding the contract method 0xaeb255ea.
+//
+// Solidity: function KEY_USAGE_OID() view returns(bytes32)
+func (_CertManager *CertManagerCaller) KEYUSAGEOID(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _CertManager.contract.Call(opts, &out, "KEY_USAGE_OID")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// KEYUSAGEOID is a free data retrieval call binding the contract method 0xaeb255ea.
+//
+// Solidity: function KEY_USAGE_OID() view returns(bytes32)
+func (_CertManager *CertManagerSession) KEYUSAGEOID() ([32]byte, error) {
+	return _CertManager.Contract.KEYUSAGEOID(&_CertManager.CallOpts)
+}
+
+// KEYUSAGEOID is a free data retrieval call binding the contract method 0xaeb255ea.
+//
+// Solidity: function KEY_USAGE_OID() view returns(bytes32)
+func (_CertManager *CertManagerCallerSession) KEYUSAGEOID() ([32]byte, error) {
+	return _CertManager.Contract.KEYUSAGEOID(&_CertManager.CallOpts)
+}
+
+// ROOTCACERTHASH is a free data retrieval call binding the contract method 0x8fb57b62.
+//
+// Solidity: function ROOT_CA_CERT_HASH() view returns(bytes32)
+func (_CertManager *CertManagerCaller) ROOTCACERTHASH(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _CertManager.contract.Call(opts, &out, "ROOT_CA_CERT_HASH")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// ROOTCACERTHASH is a free data retrieval call binding the contract method 0x8fb57b62.
+//
+// Solidity: function ROOT_CA_CERT_HASH() view returns(bytes32)
+func (_CertManager *CertManagerSession) ROOTCACERTHASH() ([32]byte, error) {
+	return _CertManager.Contract.ROOTCACERTHASH(&_CertManager.CallOpts)
+}
+
+// ROOTCACERTHASH is a free data retrieval call binding the contract method 0x8fb57b62.
+//
+// Solidity: function ROOT_CA_CERT_HASH() view returns(bytes32)
+func (_CertManager *CertManagerCallerSession) ROOTCACERTHASH() ([32]byte, error) {
+	return _CertManager.Contract.ROOTCACERTHASH(&_CertManager.CallOpts)
+}
+
+// ROOTCACERTMAXPATHLEN is a free data retrieval call binding the contract method 0x9ecc0050.
+//
+// Solidity: function ROOT_CA_CERT_MAX_PATH_LEN() view returns(int64)
+func (_CertManager *CertManagerCaller) ROOTCACERTMAXPATHLEN(opts *bind.CallOpts) (int64, error) {
+	var out []interface{}
+	err := _CertManager.contract.Call(opts, &out, "ROOT_CA_CERT_MAX_PATH_LEN")
+
+	if err != nil {
+		return *new(int64), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(int64)).(*int64)
+
+	return out0, err
+
+}
+
+// ROOTCACERTMAXPATHLEN is a free data retrieval call binding the contract method 0x9ecc0050.
+//
+// Solidity: function ROOT_CA_CERT_MAX_PATH_LEN() view returns(int64)
+func (_CertManager *CertManagerSession) ROOTCACERTMAXPATHLEN() (int64, error) {
+	return _CertManager.Contract.ROOTCACERTMAXPATHLEN(&_CertManager.CallOpts)
+}
+
+// ROOTCACERTMAXPATHLEN is a free data retrieval call binding the contract method 0x9ecc0050.
+//
+// Solidity: function ROOT_CA_CERT_MAX_PATH_LEN() view returns(int64)
+func (_CertManager *CertManagerCallerSession) ROOTCACERTMAXPATHLEN() (int64, error) {
+	return _CertManager.Contract.ROOTCACERTMAXPATHLEN(&_CertManager.CallOpts)
+}
+
+// ROOTCACERTNOTAFTER is a free data retrieval call binding the contract method 0x58e3139e.
+//
+// Solidity: function ROOT_CA_CERT_NOT_AFTER() view returns(uint64)
+func (_CertManager *CertManagerCaller) ROOTCACERTNOTAFTER(opts *bind.CallOpts) (uint64, error) {
+	var out []interface{}
+	err := _CertManager.contract.Call(opts, &out, "ROOT_CA_CERT_NOT_AFTER")
+
+	if err != nil {
+		return *new(uint64), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64)
+
+	return out0, err
+
+}
+
+// ROOTCACERTNOTAFTER is a free data retrieval call binding the contract method 0x58e3139e.
+//
+// Solidity: function ROOT_CA_CERT_NOT_AFTER() view returns(uint64)
+func (_CertManager *CertManagerSession) ROOTCACERTNOTAFTER() (uint64, error) {
+	return _CertManager.Contract.ROOTCACERTNOTAFTER(&_CertManager.CallOpts)
+}
+
+// ROOTCACERTNOTAFTER is a free data retrieval call binding the contract method 0x58e3139e.
+//
+// Solidity: function ROOT_CA_CERT_NOT_AFTER() view returns(uint64)
+func (_CertManager *CertManagerCallerSession) ROOTCACERTNOTAFTER() (uint64, error) {
+	return _CertManager.Contract.ROOTCACERTNOTAFTER(&_CertManager.CallOpts)
+}
+
+// ROOTCACERTPUBKEY is a free data retrieval call binding the contract method 0xab68988d.
+//
+// Solidity: function ROOT_CA_CERT_PUB_KEY() view returns(bytes)
+func (_CertManager *CertManagerCaller) ROOTCACERTPUBKEY(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _CertManager.contract.Call(opts, &out, "ROOT_CA_CERT_PUB_KEY")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ROOTCACERTPUBKEY is a free data retrieval call binding the contract method 0xab68988d.
+//
+// Solidity: function ROOT_CA_CERT_PUB_KEY() view returns(bytes)
+func (_CertManager *CertManagerSession) ROOTCACERTPUBKEY() ([]byte, error) {
+	return _CertManager.Contract.ROOTCACERTPUBKEY(&_CertManager.CallOpts)
+}
+
+// ROOTCACERTPUBKEY is a free data retrieval call binding the contract method 0xab68988d.
+//
+// Solidity: function ROOT_CA_CERT_PUB_KEY() view returns(bytes)
+func (_CertManager *CertManagerCallerSession) ROOTCACERTPUBKEY() ([]byte, error) {
+	return _CertManager.Contract.ROOTCACERTPUBKEY(&_CertManager.CallOpts)
+}
+
+// ROOTCACERTSUBJECTHASH is a free data retrieval call binding the contract method 0x441b31df.
+//
+// Solidity: function ROOT_CA_CERT_SUBJECT_HASH() view returns(bytes32)
+func (_CertManager *CertManagerCaller) ROOTCACERTSUBJECTHASH(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _CertManager.contract.Call(opts, &out, "ROOT_CA_CERT_SUBJECT_HASH")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// ROOTCACERTSUBJECTHASH is a free data retrieval call binding the contract method 0x441b31df.
+//
+// Solidity: function ROOT_CA_CERT_SUBJECT_HASH() view returns(bytes32)
+func (_CertManager *CertManagerSession) ROOTCACERTSUBJECTHASH() ([32]byte, error) {
+	return _CertManager.Contract.ROOTCACERTSUBJECTHASH(&_CertManager.CallOpts)
+}
+
+// ROOTCACERTSUBJECTHASH is a free data retrieval call binding the contract method 0x441b31df.
+//
+// Solidity: function ROOT_CA_CERT_SUBJECT_HASH() view returns(bytes32)
+func (_CertManager *CertManagerCallerSession) ROOTCACERTSUBJECTHASH() ([32]byte, error) {
+	return _CertManager.Contract.ROOTCACERTSUBJECTHASH(&_CertManager.CallOpts)
+}
+
+// SECP384R1OID is a free data retrieval call binding the contract method 0x5ab70904.
+//
+// Solidity: function SECP_384_R1_OID() view returns(bytes32)
+func (_CertManager *CertManagerCaller) SECP384R1OID(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _CertManager.contract.Call(opts, &out, "SECP_384_R1_OID")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// SECP384R1OID is a free data retrieval call binding the contract method 0x5ab70904.
+//
+// Solidity: function SECP_384_R1_OID() view returns(bytes32)
+func (_CertManager *CertManagerSession) SECP384R1OID() ([32]byte, error) {
+	return _CertManager.Contract.SECP384R1OID(&_CertManager.CallOpts)
+}
+
+// SECP384R1OID is a free data retrieval call binding the contract method 0x5ab70904.
+//
+// Solidity: function SECP_384_R1_OID() view returns(bytes32)
+func (_CertManager *CertManagerCallerSession) SECP384R1OID() ([32]byte, error) {
+	return _CertManager.Contract.SECP384R1OID(&_CertManager.CallOpts)
+}
+
+// Verified is a free data retrieval call binding the contract method 0xc59e43e5.
+//
+// Solidity: function verified(bytes32 ) view returns(bytes)
+func (_CertManager *CertManagerCaller) Verified(opts *bind.CallOpts, arg0 [32]byte) ([]byte, error) {
+	var out []interface{}
+	err := _CertManager.contract.Call(opts, &out, "verified", arg0)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// Verified is a free data retrieval call binding the contract method 0xc59e43e5.
+//
+// Solidity: function verified(bytes32 ) view returns(bytes)
+func (_CertManager *CertManagerSession) Verified(arg0 [32]byte) ([]byte, error) {
+	return _CertManager.Contract.Verified(&_CertManager.CallOpts, arg0)
+}
+
+// Verified is a free data retrieval call binding the contract method 0xc59e43e5.
+//
+// Solidity: function verified(bytes32 ) view returns(bytes)
+func (_CertManager *CertManagerCallerSession) Verified(arg0 [32]byte) ([]byte, error) {
+	return _CertManager.Contract.Verified(&_CertManager.CallOpts, arg0)
+}
+
+// VerifyCACert is a paid mutator transaction binding the contract method 0x0890702c.
+//
+// Solidity: function verifyCACert(bytes cert, bytes32 parentCertHash) returns(bytes32)
+func (_CertManager *CertManagerTransactor) VerifyCACert(opts *bind.TransactOpts, cert []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _CertManager.contract.Transact(opts, "verifyCACert", cert, parentCertHash)
+}
+
+// VerifyCACert is a paid mutator transaction binding the contract method 0x0890702c.
+//
+// Solidity: function verifyCACert(bytes cert, bytes32 parentCertHash) returns(bytes32)
+func (_CertManager *CertManagerSession) VerifyCACert(cert []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _CertManager.Contract.VerifyCACert(&_CertManager.TransactOpts, cert, parentCertHash)
+}
+
+// VerifyCACert is a paid mutator transaction binding the contract method 0x0890702c.
+//
+// Solidity: function verifyCACert(bytes cert, bytes32 parentCertHash) returns(bytes32)
+func (_CertManager *CertManagerTransactorSession) VerifyCACert(cert []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _CertManager.Contract.VerifyCACert(&_CertManager.TransactOpts, cert, parentCertHash)
+}
+
+// VerifyClientCert is a paid mutator transaction binding the contract method 0x28c54637.
+//
+// Solidity: function verifyClientCert(bytes cert, bytes32 parentCertHash) returns((bool,uint64,int64,bytes32,bytes))
+func (_CertManager *CertManagerTransactor) VerifyClientCert(opts *bind.TransactOpts, cert []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _CertManager.contract.Transact(opts, "verifyClientCert", cert, parentCertHash)
+}
+
+// VerifyClientCert is a paid mutator transaction binding the contract method 0x28c54637.
+//
+// Solidity: function verifyClientCert(bytes cert, bytes32 parentCertHash) returns((bool,uint64,int64,bytes32,bytes))
+func (_CertManager *CertManagerSession) VerifyClientCert(cert []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _CertManager.Contract.VerifyClientCert(&_CertManager.TransactOpts, cert, parentCertHash)
+}
+
+// VerifyClientCert is a paid mutator transaction binding the contract method 0x28c54637.
+//
+// Solidity: function verifyClientCert(bytes cert, bytes32 parentCertHash) returns((bool,uint64,int64,bytes32,bytes))
+func (_CertManager *CertManagerTransactorSession) VerifyClientCert(cert []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _CertManager.Contract.VerifyClientCert(&_CertManager.TransactOpts, cert, parentCertHash)
+}
+
+// CertManagerCertVerifiedIterator is returned from FilterCertVerified and is used to iterate over the raw logs and unpacked data for CertVerified events raised by the CertManager contract.
+type CertManagerCertVerifiedIterator struct {
+	Event *CertManagerCertVerified // 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 *CertManagerCertVerifiedIterator) 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(CertManagerCertVerified)
+			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(CertManagerCertVerified)
+		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 *CertManagerCertVerifiedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *CertManagerCertVerifiedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// CertManagerCertVerified represents a CertVerified event raised by the CertManager contract.
+type CertManagerCertVerified struct {
+	CertHash [32]byte
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterCertVerified is a free log retrieval operation binding the contract event 0x694e63280ec3524c75db17994cf1341b1dbc3efa9f68ad3f4b8da1f00804828e.
+//
+// Solidity: event CertVerified(bytes32 indexed certHash)
+func (_CertManager *CertManagerFilterer) FilterCertVerified(opts *bind.FilterOpts, certHash [][32]byte) (*CertManagerCertVerifiedIterator, error) {
+
+	var certHashRule []interface{}
+	for _, certHashItem := range certHash {
+		certHashRule = append(certHashRule, certHashItem)
+	}
+
+	logs, sub, err := _CertManager.contract.FilterLogs(opts, "CertVerified", certHashRule)
+	if err != nil {
+		return nil, err
+	}
+	return &CertManagerCertVerifiedIterator{contract: _CertManager.contract, event: "CertVerified", logs: logs, sub: sub}, nil
+}
+
+// WatchCertVerified is a free log subscription operation binding the contract event 0x694e63280ec3524c75db17994cf1341b1dbc3efa9f68ad3f4b8da1f00804828e.
+//
+// Solidity: event CertVerified(bytes32 indexed certHash)
+func (_CertManager *CertManagerFilterer) WatchCertVerified(opts *bind.WatchOpts, sink chan<- *CertManagerCertVerified, certHash [][32]byte) (event.Subscription, error) {
+
+	var certHashRule []interface{}
+	for _, certHashItem := range certHash {
+		certHashRule = append(certHashRule, certHashItem)
+	}
+
+	logs, sub, err := _CertManager.contract.WatchLogs(opts, "CertVerified", certHashRule)
+	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(CertManagerCertVerified)
+				if err := _CertManager.contract.UnpackLog(event, "CertVerified", 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
+}
+
+// ParseCertVerified is a log parse operation binding the contract event 0x694e63280ec3524c75db17994cf1341b1dbc3efa9f68ad3f4b8da1f00804828e.
+//
+// Solidity: event CertVerified(bytes32 indexed certHash)
+func (_CertManager *CertManagerFilterer) ParseCertVerified(log types.Log) (*CertManagerCertVerified, error) {
+	event := new(CertManagerCertVerified)
+	if err := _CertManager.contract.UnpackLog(event, "CertVerified", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// CommonBaseMetaData contains all meta data concerning the CommonBase contract.
+var CommonBaseMetaData = &bind.MetaData{
+	ABI: "[]",
+}
+
+// CommonBaseABI is the input ABI used to generate the binding from.
+// Deprecated: Use CommonBaseMetaData.ABI instead.
+var CommonBaseABI = CommonBaseMetaData.ABI
+
+// CommonBase is an auto generated Go binding around an Ethereum contract.
+type CommonBase struct {
+	CommonBaseCaller     // Read-only binding to the contract
+	CommonBaseTransactor // Write-only binding to the contract
+	CommonBaseFilterer   // Log filterer for contract events
+}
+
+// CommonBaseCaller is an auto generated read-only Go binding around an Ethereum contract.
+type CommonBaseCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// CommonBaseTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type CommonBaseTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// CommonBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type CommonBaseFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// CommonBaseSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type CommonBaseSession struct {
+	Contract     *CommonBase       // 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
+}
+
+// CommonBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type CommonBaseCallerSession struct {
+	Contract *CommonBaseCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts     // Call options to use throughout this session
+}
+
+// CommonBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type CommonBaseTransactorSession struct {
+	Contract     *CommonBaseTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
+}
+
+// CommonBaseRaw is an auto generated low-level Go binding around an Ethereum contract.
+type CommonBaseRaw struct {
+	Contract *CommonBase // Generic contract binding to access the raw methods on
+}
+
+// CommonBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type CommonBaseCallerRaw struct {
+	Contract *CommonBaseCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// CommonBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type CommonBaseTransactorRaw struct {
+	Contract *CommonBaseTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewCommonBase creates a new instance of CommonBase, bound to a specific deployed contract.
+func NewCommonBase(address common.Address, backend bind.ContractBackend) (*CommonBase, error) {
+	contract, err := bindCommonBase(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &CommonBase{CommonBaseCaller: CommonBaseCaller{contract: contract}, CommonBaseTransactor: CommonBaseTransactor{contract: contract}, CommonBaseFilterer: CommonBaseFilterer{contract: contract}}, nil
+}
+
+// NewCommonBaseCaller creates a new read-only instance of CommonBase, bound to a specific deployed contract.
+func NewCommonBaseCaller(address common.Address, caller bind.ContractCaller) (*CommonBaseCaller, error) {
+	contract, err := bindCommonBase(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &CommonBaseCaller{contract: contract}, nil
+}
+
+// NewCommonBaseTransactor creates a new write-only instance of CommonBase, bound to a specific deployed contract.
+func NewCommonBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*CommonBaseTransactor, error) {
+	contract, err := bindCommonBase(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &CommonBaseTransactor{contract: contract}, nil
+}
+
+// NewCommonBaseFilterer creates a new log filterer instance of CommonBase, bound to a specific deployed contract.
+func NewCommonBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*CommonBaseFilterer, error) {
+	contract, err := bindCommonBase(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &CommonBaseFilterer{contract: contract}, nil
+}
+
+// bindCommonBase binds a generic wrapper to an already deployed contract.
+func bindCommonBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := CommonBaseMetaData.GetAbi()
+	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 (_CommonBase *CommonBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _CommonBase.Contract.CommonBaseCaller.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 (_CommonBase *CommonBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _CommonBase.Contract.CommonBaseTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_CommonBase *CommonBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _CommonBase.Contract.CommonBaseTransactor.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 (_CommonBase *CommonBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _CommonBase.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 (_CommonBase *CommonBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _CommonBase.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_CommonBase *CommonBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _CommonBase.Contract.contract.Transact(opts, method, params...)
+}
+
+// ContextMetaData contains all meta data concerning the Context contract.
+var ContextMetaData = &bind.MetaData{
+	ABI: "[]",
+}
+
+// ContextABI is the input ABI used to generate the binding from.
+// Deprecated: Use ContextMetaData.ABI instead.
+var ContextABI = ContextMetaData.ABI
+
+// Context is an auto generated Go binding around an Ethereum contract.
+type Context struct {
+	ContextCaller     // Read-only binding to the contract
+	ContextTransactor // Write-only binding to the contract
+	ContextFilterer   // Log filterer for contract events
+}
+
+// ContextCaller is an auto generated read-only Go binding around an Ethereum contract.
+type ContextCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ContextTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type ContextTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ContextFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type ContextFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ContextSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type ContextSession struct {
+	Contract     *Context          // 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
+}
+
+// ContextCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type ContextCallerSession struct {
+	Contract *ContextCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts  // Call options to use throughout this session
+}
+
+// ContextTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type ContextTransactorSession struct {
+	Contract     *ContextTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
+}
+
+// ContextRaw is an auto generated low-level Go binding around an Ethereum contract.
+type ContextRaw struct {
+	Contract *Context // Generic contract binding to access the raw methods on
+}
+
+// ContextCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type ContextCallerRaw struct {
+	Contract *ContextCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// ContextTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type ContextTransactorRaw struct {
+	Contract *ContextTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewContext creates a new instance of Context, bound to a specific deployed contract.
+func NewContext(address common.Address, backend bind.ContractBackend) (*Context, error) {
+	contract, err := bindContext(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Context{ContextCaller: ContextCaller{contract: contract}, ContextTransactor: ContextTransactor{contract: contract}, ContextFilterer: ContextFilterer{contract: contract}}, nil
+}
+
+// NewContextCaller creates a new read-only instance of Context, bound to a specific deployed contract.
+func NewContextCaller(address common.Address, caller bind.ContractCaller) (*ContextCaller, error) {
+	contract, err := bindContext(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ContextCaller{contract: contract}, nil
+}
+
+// NewContextTransactor creates a new write-only instance of Context, bound to a specific deployed contract.
+func NewContextTransactor(address common.Address, transactor bind.ContractTransactor) (*ContextTransactor, error) {
+	contract, err := bindContext(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ContextTransactor{contract: contract}, nil
+}
+
+// NewContextFilterer creates a new log filterer instance of Context, bound to a specific deployed contract.
+func NewContextFilterer(address common.Address, filterer bind.ContractFilterer) (*ContextFilterer, error) {
+	contract, err := bindContext(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &ContextFilterer{contract: contract}, nil
+}
+
+// bindContext binds a generic wrapper to an already deployed contract.
+func bindContext(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := ContextMetaData.GetAbi()
+	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 (_Context *ContextRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Context.Contract.ContextCaller.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 (_Context *ContextRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Context.Contract.ContextTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Context *ContextRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Context.Contract.ContextTransactor.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 (_Context *ContextCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Context.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 (_Context *ContextTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Context.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Context *ContextTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Context.Contract.contract.Transact(opts, method, params...)
+}
+
+// DaoBaseMetaData contains all meta data concerning the DaoBase contract.
+var DaoBaseMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"}],\"name\":\"getAttestedData\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"attestationData\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"}],\"name\":\"getCollateralHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"collateralHash\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resolver\",\"outputs\":[{\"internalType\":\"contractIDaoAttestationResolver\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+}
+
+// DaoBaseABI is the input ABI used to generate the binding from.
+// Deprecated: Use DaoBaseMetaData.ABI instead.
+var DaoBaseABI = DaoBaseMetaData.ABI
+
+// DaoBase is an auto generated Go binding around an Ethereum contract.
+type DaoBase struct {
+	DaoBaseCaller     // Read-only binding to the contract
+	DaoBaseTransactor // Write-only binding to the contract
+	DaoBaseFilterer   // Log filterer for contract events
+}
+
+// DaoBaseCaller is an auto generated read-only Go binding around an Ethereum contract.
+type DaoBaseCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DaoBaseTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type DaoBaseTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DaoBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type DaoBaseFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DaoBaseSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type DaoBaseSession struct {
+	Contract     *DaoBase          // 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
+}
+
+// DaoBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type DaoBaseCallerSession struct {
+	Contract *DaoBaseCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts  // Call options to use throughout this session
+}
+
+// DaoBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type DaoBaseTransactorSession struct {
+	Contract     *DaoBaseTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
+}
+
+// DaoBaseRaw is an auto generated low-level Go binding around an Ethereum contract.
+type DaoBaseRaw struct {
+	Contract *DaoBase // Generic contract binding to access the raw methods on
+}
+
+// DaoBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type DaoBaseCallerRaw struct {
+	Contract *DaoBaseCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// DaoBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type DaoBaseTransactorRaw struct {
+	Contract *DaoBaseTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewDaoBase creates a new instance of DaoBase, bound to a specific deployed contract.
+func NewDaoBase(address common.Address, backend bind.ContractBackend) (*DaoBase, error) {
+	contract, err := bindDaoBase(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &DaoBase{DaoBaseCaller: DaoBaseCaller{contract: contract}, DaoBaseTransactor: DaoBaseTransactor{contract: contract}, DaoBaseFilterer: DaoBaseFilterer{contract: contract}}, nil
+}
+
+// NewDaoBaseCaller creates a new read-only instance of DaoBase, bound to a specific deployed contract.
+func NewDaoBaseCaller(address common.Address, caller bind.ContractCaller) (*DaoBaseCaller, error) {
+	contract, err := bindDaoBase(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DaoBaseCaller{contract: contract}, nil
+}
+
+// NewDaoBaseTransactor creates a new write-only instance of DaoBase, bound to a specific deployed contract.
+func NewDaoBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*DaoBaseTransactor, error) {
+	contract, err := bindDaoBase(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DaoBaseTransactor{contract: contract}, nil
+}
+
+// NewDaoBaseFilterer creates a new log filterer instance of DaoBase, bound to a specific deployed contract.
+func NewDaoBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*DaoBaseFilterer, error) {
+	contract, err := bindDaoBase(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &DaoBaseFilterer{contract: contract}, nil
+}
+
+// bindDaoBase binds a generic wrapper to an already deployed contract.
+func bindDaoBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := DaoBaseMetaData.GetAbi()
+	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 (_DaoBase *DaoBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _DaoBase.Contract.DaoBaseCaller.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 (_DaoBase *DaoBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _DaoBase.Contract.DaoBaseTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_DaoBase *DaoBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _DaoBase.Contract.DaoBaseTransactor.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 (_DaoBase *DaoBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _DaoBase.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 (_DaoBase *DaoBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _DaoBase.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_DaoBase *DaoBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _DaoBase.Contract.contract.Transact(opts, method, params...)
+}
+
+// GetAttestedData is a free data retrieval call binding the contract method 0xb414d0b2.
+//
+// Solidity: function getAttestedData(bytes32 key) view returns(bytes attestationData)
+func (_DaoBase *DaoBaseCaller) GetAttestedData(opts *bind.CallOpts, key [32]byte) ([]byte, error) {
+	var out []interface{}
+	err := _DaoBase.contract.Call(opts, &out, "getAttestedData", key)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// GetAttestedData is a free data retrieval call binding the contract method 0xb414d0b2.
+//
+// Solidity: function getAttestedData(bytes32 key) view returns(bytes attestationData)
+func (_DaoBase *DaoBaseSession) GetAttestedData(key [32]byte) ([]byte, error) {
+	return _DaoBase.Contract.GetAttestedData(&_DaoBase.CallOpts, key)
+}
+
+// GetAttestedData is a free data retrieval call binding the contract method 0xb414d0b2.
+//
+// Solidity: function getAttestedData(bytes32 key) view returns(bytes attestationData)
+func (_DaoBase *DaoBaseCallerSession) GetAttestedData(key [32]byte) ([]byte, error) {
+	return _DaoBase.Contract.GetAttestedData(&_DaoBase.CallOpts, key)
+}
+
+// GetCollateralHash is a free data retrieval call binding the contract method 0xbf721aaf.
+//
+// Solidity: function getCollateralHash(bytes32 key) view returns(bytes32 collateralHash)
+func (_DaoBase *DaoBaseCaller) GetCollateralHash(opts *bind.CallOpts, key [32]byte) ([32]byte, error) {
+	var out []interface{}
+	err := _DaoBase.contract.Call(opts, &out, "getCollateralHash", key)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// GetCollateralHash is a free data retrieval call binding the contract method 0xbf721aaf.
+//
+// Solidity: function getCollateralHash(bytes32 key) view returns(bytes32 collateralHash)
+func (_DaoBase *DaoBaseSession) GetCollateralHash(key [32]byte) ([32]byte, error) {
+	return _DaoBase.Contract.GetCollateralHash(&_DaoBase.CallOpts, key)
+}
+
+// GetCollateralHash is a free data retrieval call binding the contract method 0xbf721aaf.
+//
+// Solidity: function getCollateralHash(bytes32 key) view returns(bytes32 collateralHash)
+func (_DaoBase *DaoBaseCallerSession) GetCollateralHash(key [32]byte) ([32]byte, error) {
+	return _DaoBase.Contract.GetCollateralHash(&_DaoBase.CallOpts, key)
+}
+
+// Resolver is a free data retrieval call binding the contract method 0x04f3bcec.
+//
+// Solidity: function resolver() view returns(address)
+func (_DaoBase *DaoBaseCaller) Resolver(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _DaoBase.contract.Call(opts, &out, "resolver")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// Resolver is a free data retrieval call binding the contract method 0x04f3bcec.
+//
+// Solidity: function resolver() view returns(address)
+func (_DaoBase *DaoBaseSession) Resolver() (common.Address, error) {
+	return _DaoBase.Contract.Resolver(&_DaoBase.CallOpts)
+}
+
+// Resolver is a free data retrieval call binding the contract method 0x04f3bcec.
+//
+// Solidity: function resolver() view returns(address)
+func (_DaoBase *DaoBaseCallerSession) Resolver() (common.Address, error) {
+	return _DaoBase.Contract.Resolver(&_DaoBase.CallOpts)
+}
+
+// DateTimeLibMetaData contains all meta data concerning the DateTimeLib contract.
+var DateTimeLibMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220404403088771a520a92a0ae8f3ae7f4d3618fd02d62d108d11d1a1468d91e44a64736f6c63430008190033",
+}
+
+// DateTimeLibABI is the input ABI used to generate the binding from.
+// Deprecated: Use DateTimeLibMetaData.ABI instead.
+var DateTimeLibABI = DateTimeLibMetaData.ABI
+
+// DateTimeLibBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use DateTimeLibMetaData.Bin instead.
+var DateTimeLibBin = DateTimeLibMetaData.Bin
+
+// DeployDateTimeLib deploys a new Ethereum contract, binding an instance of DateTimeLib to it.
+func DeployDateTimeLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *DateTimeLib, error) {
+	parsed, err := DateTimeLibMetaData.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(DateTimeLibBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &DateTimeLib{DateTimeLibCaller: DateTimeLibCaller{contract: contract}, DateTimeLibTransactor: DateTimeLibTransactor{contract: contract}, DateTimeLibFilterer: DateTimeLibFilterer{contract: contract}}, nil
+}
+
+// DateTimeLib is an auto generated Go binding around an Ethereum contract.
+type DateTimeLib struct {
+	DateTimeLibCaller     // Read-only binding to the contract
+	DateTimeLibTransactor // Write-only binding to the contract
+	DateTimeLibFilterer   // Log filterer for contract events
+}
+
+// DateTimeLibCaller is an auto generated read-only Go binding around an Ethereum contract.
+type DateTimeLibCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DateTimeLibTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type DateTimeLibTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DateTimeLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type DateTimeLibFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DateTimeLibSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type DateTimeLibSession struct {
+	Contract     *DateTimeLib      // 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
+}
+
+// DateTimeLibCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type DateTimeLibCallerSession struct {
+	Contract *DateTimeLibCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts      // Call options to use throughout this session
+}
+
+// DateTimeLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type DateTimeLibTransactorSession struct {
+	Contract     *DateTimeLibTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts      // Transaction auth options to use throughout this session
+}
+
+// DateTimeLibRaw is an auto generated low-level Go binding around an Ethereum contract.
+type DateTimeLibRaw struct {
+	Contract *DateTimeLib // Generic contract binding to access the raw methods on
+}
+
+// DateTimeLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type DateTimeLibCallerRaw struct {
+	Contract *DateTimeLibCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// DateTimeLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type DateTimeLibTransactorRaw struct {
+	Contract *DateTimeLibTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewDateTimeLib creates a new instance of DateTimeLib, bound to a specific deployed contract.
+func NewDateTimeLib(address common.Address, backend bind.ContractBackend) (*DateTimeLib, error) {
+	contract, err := bindDateTimeLib(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &DateTimeLib{DateTimeLibCaller: DateTimeLibCaller{contract: contract}, DateTimeLibTransactor: DateTimeLibTransactor{contract: contract}, DateTimeLibFilterer: DateTimeLibFilterer{contract: contract}}, nil
+}
+
+// NewDateTimeLibCaller creates a new read-only instance of DateTimeLib, bound to a specific deployed contract.
+func NewDateTimeLibCaller(address common.Address, caller bind.ContractCaller) (*DateTimeLibCaller, error) {
+	contract, err := bindDateTimeLib(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DateTimeLibCaller{contract: contract}, nil
+}
+
+// NewDateTimeLibTransactor creates a new write-only instance of DateTimeLib, bound to a specific deployed contract.
+func NewDateTimeLibTransactor(address common.Address, transactor bind.ContractTransactor) (*DateTimeLibTransactor, error) {
+	contract, err := bindDateTimeLib(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DateTimeLibTransactor{contract: contract}, nil
+}
+
+// NewDateTimeLibFilterer creates a new log filterer instance of DateTimeLib, bound to a specific deployed contract.
+func NewDateTimeLibFilterer(address common.Address, filterer bind.ContractFilterer) (*DateTimeLibFilterer, error) {
+	contract, err := bindDateTimeLib(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &DateTimeLibFilterer{contract: contract}, nil
+}
+
+// bindDateTimeLib binds a generic wrapper to an already deployed contract.
+func bindDateTimeLib(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := DateTimeLibMetaData.GetAbi()
+	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 (_DateTimeLib *DateTimeLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _DateTimeLib.Contract.DateTimeLibCaller.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 (_DateTimeLib *DateTimeLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _DateTimeLib.Contract.DateTimeLibTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_DateTimeLib *DateTimeLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _DateTimeLib.Contract.DateTimeLibTransactor.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 (_DateTimeLib *DateTimeLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _DateTimeLib.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 (_DateTimeLib *DateTimeLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _DateTimeLib.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_DateTimeLib *DateTimeLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _DateTimeLib.Contract.contract.Transact(opts, method, params...)
+}
+
+// DateTimeUtilsMetaData contains all meta data concerning the DateTimeUtils contract.
+var DateTimeUtilsMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212207d22c78a22f10909477a3efd79262210ef2aec38e747a4bcee90ce37cd04b1c964736f6c63430008190033",
+}
+
+// DateTimeUtilsABI is the input ABI used to generate the binding from.
+// Deprecated: Use DateTimeUtilsMetaData.ABI instead.
+var DateTimeUtilsABI = DateTimeUtilsMetaData.ABI
+
+// DateTimeUtilsBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use DateTimeUtilsMetaData.Bin instead.
+var DateTimeUtilsBin = DateTimeUtilsMetaData.Bin
+
+// DeployDateTimeUtils deploys a new Ethereum contract, binding an instance of DateTimeUtils to it.
+func DeployDateTimeUtils(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *DateTimeUtils, error) {
+	parsed, err := DateTimeUtilsMetaData.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(DateTimeUtilsBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &DateTimeUtils{DateTimeUtilsCaller: DateTimeUtilsCaller{contract: contract}, DateTimeUtilsTransactor: DateTimeUtilsTransactor{contract: contract}, DateTimeUtilsFilterer: DateTimeUtilsFilterer{contract: contract}}, nil
+}
+
+// DateTimeUtils is an auto generated Go binding around an Ethereum contract.
+type DateTimeUtils struct {
+	DateTimeUtilsCaller     // Read-only binding to the contract
+	DateTimeUtilsTransactor // Write-only binding to the contract
+	DateTimeUtilsFilterer   // Log filterer for contract events
+}
+
+// DateTimeUtilsCaller is an auto generated read-only Go binding around an Ethereum contract.
+type DateTimeUtilsCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DateTimeUtilsTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type DateTimeUtilsTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DateTimeUtilsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type DateTimeUtilsFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DateTimeUtilsSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type DateTimeUtilsSession struct {
+	Contract     *DateTimeUtils    // 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
+}
+
+// DateTimeUtilsCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type DateTimeUtilsCallerSession struct {
+	Contract *DateTimeUtilsCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts        // Call options to use throughout this session
+}
+
+// DateTimeUtilsTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type DateTimeUtilsTransactorSession struct {
+	Contract     *DateTimeUtilsTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
+}
+
+// DateTimeUtilsRaw is an auto generated low-level Go binding around an Ethereum contract.
+type DateTimeUtilsRaw struct {
+	Contract *DateTimeUtils // Generic contract binding to access the raw methods on
+}
+
+// DateTimeUtilsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type DateTimeUtilsCallerRaw struct {
+	Contract *DateTimeUtilsCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// DateTimeUtilsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type DateTimeUtilsTransactorRaw struct {
+	Contract *DateTimeUtilsTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewDateTimeUtils creates a new instance of DateTimeUtils, bound to a specific deployed contract.
+func NewDateTimeUtils(address common.Address, backend bind.ContractBackend) (*DateTimeUtils, error) {
+	contract, err := bindDateTimeUtils(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &DateTimeUtils{DateTimeUtilsCaller: DateTimeUtilsCaller{contract: contract}, DateTimeUtilsTransactor: DateTimeUtilsTransactor{contract: contract}, DateTimeUtilsFilterer: DateTimeUtilsFilterer{contract: contract}}, nil
+}
+
+// NewDateTimeUtilsCaller creates a new read-only instance of DateTimeUtils, bound to a specific deployed contract.
+func NewDateTimeUtilsCaller(address common.Address, caller bind.ContractCaller) (*DateTimeUtilsCaller, error) {
+	contract, err := bindDateTimeUtils(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DateTimeUtilsCaller{contract: contract}, nil
+}
+
+// NewDateTimeUtilsTransactor creates a new write-only instance of DateTimeUtils, bound to a specific deployed contract.
+func NewDateTimeUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*DateTimeUtilsTransactor, error) {
+	contract, err := bindDateTimeUtils(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DateTimeUtilsTransactor{contract: contract}, nil
+}
+
+// NewDateTimeUtilsFilterer creates a new log filterer instance of DateTimeUtils, bound to a specific deployed contract.
+func NewDateTimeUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*DateTimeUtilsFilterer, error) {
+	contract, err := bindDateTimeUtils(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &DateTimeUtilsFilterer{contract: contract}, nil
+}
+
+// bindDateTimeUtils binds a generic wrapper to an already deployed contract.
+func bindDateTimeUtils(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := DateTimeUtilsMetaData.GetAbi()
+	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 (_DateTimeUtils *DateTimeUtilsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _DateTimeUtils.Contract.DateTimeUtilsCaller.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 (_DateTimeUtils *DateTimeUtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _DateTimeUtils.Contract.DateTimeUtilsTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_DateTimeUtils *DateTimeUtilsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _DateTimeUtils.Contract.DateTimeUtilsTransactor.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 (_DateTimeUtils *DateTimeUtilsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _DateTimeUtils.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 (_DateTimeUtils *DateTimeUtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _DateTimeUtils.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_DateTimeUtils *DateTimeUtilsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _DateTimeUtils.Contract.contract.Transact(opts, method, params...)
+}
+
+// ECDSAMetaData contains all meta data concerning the ECDSA contract.
+var ECDSAMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea264697066735822122051ce5b6044ae5ac1c221b1b15f45ee1b181d3cd0cf86d858eca8db80dee1382a64736f6c63430008190033",
+}
+
+// ECDSAABI is the input ABI used to generate the binding from.
+// Deprecated: Use ECDSAMetaData.ABI instead.
+var ECDSAABI = ECDSAMetaData.ABI
+
+// ECDSABin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use ECDSAMetaData.Bin instead.
+var ECDSABin = ECDSAMetaData.Bin
+
+// DeployECDSA deploys a new Ethereum contract, binding an instance of ECDSA to it.
+func DeployECDSA(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ECDSA, error) {
+	parsed, err := ECDSAMetaData.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(ECDSABin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &ECDSA{ECDSACaller: ECDSACaller{contract: contract}, ECDSATransactor: ECDSATransactor{contract: contract}, ECDSAFilterer: ECDSAFilterer{contract: contract}}, nil
+}
+
+// ECDSA is an auto generated Go binding around an Ethereum contract.
+type ECDSA struct {
+	ECDSACaller     // Read-only binding to the contract
+	ECDSATransactor // Write-only binding to the contract
+	ECDSAFilterer   // Log filterer for contract events
+}
+
+// ECDSACaller is an auto generated read-only Go binding around an Ethereum contract.
+type ECDSACaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ECDSATransactor is an auto generated write-only Go binding around an Ethereum contract.
+type ECDSATransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ECDSAFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type ECDSAFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ECDSASession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type ECDSASession struct {
+	Contract     *ECDSA            // 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
+}
+
+// ECDSACallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type ECDSACallerSession struct {
+	Contract *ECDSACaller  // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts // Call options to use throughout this session
+}
+
+// ECDSATransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type ECDSATransactorSession struct {
+	Contract     *ECDSATransactor  // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// ECDSARaw is an auto generated low-level Go binding around an Ethereum contract.
+type ECDSARaw struct {
+	Contract *ECDSA // Generic contract binding to access the raw methods on
+}
+
+// ECDSACallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type ECDSACallerRaw struct {
+	Contract *ECDSACaller // Generic read-only contract binding to access the raw methods on
+}
+
+// ECDSATransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type ECDSATransactorRaw struct {
+	Contract *ECDSATransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewECDSA creates a new instance of ECDSA, bound to a specific deployed contract.
+func NewECDSA(address common.Address, backend bind.ContractBackend) (*ECDSA, error) {
+	contract, err := bindECDSA(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &ECDSA{ECDSACaller: ECDSACaller{contract: contract}, ECDSATransactor: ECDSATransactor{contract: contract}, ECDSAFilterer: ECDSAFilterer{contract: contract}}, nil
+}
+
+// NewECDSACaller creates a new read-only instance of ECDSA, bound to a specific deployed contract.
+func NewECDSACaller(address common.Address, caller bind.ContractCaller) (*ECDSACaller, error) {
+	contract, err := bindECDSA(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ECDSACaller{contract: contract}, nil
+}
+
+// NewECDSATransactor creates a new write-only instance of ECDSA, bound to a specific deployed contract.
+func NewECDSATransactor(address common.Address, transactor bind.ContractTransactor) (*ECDSATransactor, error) {
+	contract, err := bindECDSA(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ECDSATransactor{contract: contract}, nil
+}
+
+// NewECDSAFilterer creates a new log filterer instance of ECDSA, bound to a specific deployed contract.
+func NewECDSAFilterer(address common.Address, filterer bind.ContractFilterer) (*ECDSAFilterer, error) {
+	contract, err := bindECDSA(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &ECDSAFilterer{contract: contract}, nil
+}
+
+// bindECDSA binds a generic wrapper to an already deployed contract.
+func bindECDSA(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := ECDSAMetaData.GetAbi()
+	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 (_ECDSA *ECDSARaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _ECDSA.Contract.ECDSACaller.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 (_ECDSA *ECDSARaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _ECDSA.Contract.ECDSATransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_ECDSA *ECDSARaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _ECDSA.Contract.ECDSATransactor.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 (_ECDSA *ECDSACallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _ECDSA.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 (_ECDSA *ECDSATransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _ECDSA.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_ECDSA *ECDSATransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _ECDSA.Contract.contract.Transact(opts, method, params...)
+}
+
+// ECDSA384MetaData contains all meta data concerning the ECDSA384 contract.
+var ECDSA384MetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212206ff4c3a15cb21fade92d1bee9073ad0c083812e35b61e10fc26d64b69075b5b764736f6c63430008190033",
+}
+
+// ECDSA384ABI is the input ABI used to generate the binding from.
+// Deprecated: Use ECDSA384MetaData.ABI instead.
+var ECDSA384ABI = ECDSA384MetaData.ABI
+
+// ECDSA384Bin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use ECDSA384MetaData.Bin instead.
+var ECDSA384Bin = ECDSA384MetaData.Bin
+
+// DeployECDSA384 deploys a new Ethereum contract, binding an instance of ECDSA384 to it.
+func DeployECDSA384(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ECDSA384, error) {
+	parsed, err := ECDSA384MetaData.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(ECDSA384Bin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &ECDSA384{ECDSA384Caller: ECDSA384Caller{contract: contract}, ECDSA384Transactor: ECDSA384Transactor{contract: contract}, ECDSA384Filterer: ECDSA384Filterer{contract: contract}}, nil
+}
+
+// ECDSA384 is an auto generated Go binding around an Ethereum contract.
+type ECDSA384 struct {
+	ECDSA384Caller     // Read-only binding to the contract
+	ECDSA384Transactor // Write-only binding to the contract
+	ECDSA384Filterer   // Log filterer for contract events
+}
+
+// ECDSA384Caller is an auto generated read-only Go binding around an Ethereum contract.
+type ECDSA384Caller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ECDSA384Transactor is an auto generated write-only Go binding around an Ethereum contract.
+type ECDSA384Transactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ECDSA384Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type ECDSA384Filterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ECDSA384Session is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type ECDSA384Session struct {
+	Contract     *ECDSA384         // 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
+}
+
+// ECDSA384CallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type ECDSA384CallerSession struct {
+	Contract *ECDSA384Caller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts   // Call options to use throughout this session
+}
+
+// ECDSA384TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type ECDSA384TransactorSession struct {
+	Contract     *ECDSA384Transactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
+}
+
+// ECDSA384Raw is an auto generated low-level Go binding around an Ethereum contract.
+type ECDSA384Raw struct {
+	Contract *ECDSA384 // Generic contract binding to access the raw methods on
+}
+
+// ECDSA384CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type ECDSA384CallerRaw struct {
+	Contract *ECDSA384Caller // Generic read-only contract binding to access the raw methods on
+}
+
+// ECDSA384TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type ECDSA384TransactorRaw struct {
+	Contract *ECDSA384Transactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewECDSA384 creates a new instance of ECDSA384, bound to a specific deployed contract.
+func NewECDSA384(address common.Address, backend bind.ContractBackend) (*ECDSA384, error) {
+	contract, err := bindECDSA384(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &ECDSA384{ECDSA384Caller: ECDSA384Caller{contract: contract}, ECDSA384Transactor: ECDSA384Transactor{contract: contract}, ECDSA384Filterer: ECDSA384Filterer{contract: contract}}, nil
+}
+
+// NewECDSA384Caller creates a new read-only instance of ECDSA384, bound to a specific deployed contract.
+func NewECDSA384Caller(address common.Address, caller bind.ContractCaller) (*ECDSA384Caller, error) {
+	contract, err := bindECDSA384(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ECDSA384Caller{contract: contract}, nil
+}
+
+// NewECDSA384Transactor creates a new write-only instance of ECDSA384, bound to a specific deployed contract.
+func NewECDSA384Transactor(address common.Address, transactor bind.ContractTransactor) (*ECDSA384Transactor, error) {
+	contract, err := bindECDSA384(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ECDSA384Transactor{contract: contract}, nil
+}
+
+// NewECDSA384Filterer creates a new log filterer instance of ECDSA384, bound to a specific deployed contract.
+func NewECDSA384Filterer(address common.Address, filterer bind.ContractFilterer) (*ECDSA384Filterer, error) {
+	contract, err := bindECDSA384(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &ECDSA384Filterer{contract: contract}, nil
+}
+
+// bindECDSA384 binds a generic wrapper to an already deployed contract.
+func bindECDSA384(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := ECDSA384MetaData.GetAbi()
+	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 (_ECDSA384 *ECDSA384Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _ECDSA384.Contract.ECDSA384Caller.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 (_ECDSA384 *ECDSA384Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _ECDSA384.Contract.ECDSA384Transactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_ECDSA384 *ECDSA384Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _ECDSA384.Contract.ECDSA384Transactor.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 (_ECDSA384 *ECDSA384CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _ECDSA384.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 (_ECDSA384 *ECDSA384TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _ECDSA384.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_ECDSA384 *ECDSA384TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _ECDSA384.Contract.contract.Transact(opts, method, params...)
+}
+
+// ECDSA384CurveMetaData contains all meta data concerning the ECDSA384Curve contract.
+var ECDSA384CurveMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"CURVE_A\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CURVE_B\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CURVE_GX\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CURVE_GY\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CURVE_LOW_S_MAX\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CURVE_N\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CURVE_P\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+	Bin: "0x6080806040523460195761033e908161001e823930815050f35b5f80fdfe6040608081526004361015610012575f80fd5b5f3560e01c806341d36374146102665780637e9c58f414610225578063a609dfc3146101c4578063b05e505a1461017a578063b060c9bf14610119578063e6e24213146100b85763fb3b2c8f14610067575f80fd5b5f3660031901126100b4576100b09061007e6102a7565b67389cb27e0bc8d2201960208201526f2c0d06d9245853bd76760cb5666294b960811b828201529051918291826102de565b0390f35b5f80fd5b505f3660031901126100b4576100b0906100d06102a7565b7fb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875a60208201526fc656398d8a2ed19d2a85c8edd3ec2aef60801b828201529051918291826102de565b505f3660031901126100b4576100b0906101316102a7565b7faa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a3860208201526f5502f25dbf55296c3a545e3872760ab760801b828201529051918291826102de565b505f3660031901126100b4576100b0906101926102a7565b67389cb27e0bc8d2201960208201526f581a0db248b0a77aecec196accc5297360801b828201529051918291826102de565b505f3660031901126100b4576100b0906101dc6102a7565b7f3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c060208201526f0a60b1ce1d7e819d7a431d7c90ea0e5f60801b828201529051918291826102de565b505f3660031901126100b4576100b09061023d6102a7565b6001196020820152600163ffffffff60801b01600160e01b0319828201529051918291826102de565b505f3660031901126100b4576100b09061027e6102a7565b60011960208201526001633fffffff60821b01600160e01b0319828201529051918291826102de565b60405190606082016001600160401b038111838210176102ca5760405260308252565b634e487b7160e01b5f52604160045260245ffd5b602060409281835280519182918282860152018484015e5f828201840152601f01601f191601019056fea2646970667358221220fcfc4252ed9b96ab066bc7822d4dcdc742c73f797def7f9b4b0df8c711e3fba364736f6c63430008190033",
+}
+
+// ECDSA384CurveABI is the input ABI used to generate the binding from.
+// Deprecated: Use ECDSA384CurveMetaData.ABI instead.
+var ECDSA384CurveABI = ECDSA384CurveMetaData.ABI
+
+// ECDSA384CurveBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use ECDSA384CurveMetaData.Bin instead.
+var ECDSA384CurveBin = ECDSA384CurveMetaData.Bin
+
+// DeployECDSA384Curve deploys a new Ethereum contract, binding an instance of ECDSA384Curve to it.
+func DeployECDSA384Curve(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ECDSA384Curve, error) {
+	parsed, err := ECDSA384CurveMetaData.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(ECDSA384CurveBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &ECDSA384Curve{ECDSA384CurveCaller: ECDSA384CurveCaller{contract: contract}, ECDSA384CurveTransactor: ECDSA384CurveTransactor{contract: contract}, ECDSA384CurveFilterer: ECDSA384CurveFilterer{contract: contract}}, nil
+}
+
+// ECDSA384Curve is an auto generated Go binding around an Ethereum contract.
+type ECDSA384Curve struct {
+	ECDSA384CurveCaller     // Read-only binding to the contract
+	ECDSA384CurveTransactor // Write-only binding to the contract
+	ECDSA384CurveFilterer   // Log filterer for contract events
+}
+
+// ECDSA384CurveCaller is an auto generated read-only Go binding around an Ethereum contract.
+type ECDSA384CurveCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ECDSA384CurveTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type ECDSA384CurveTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ECDSA384CurveFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type ECDSA384CurveFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ECDSA384CurveSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type ECDSA384CurveSession struct {
+	Contract     *ECDSA384Curve    // 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
+}
+
+// ECDSA384CurveCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type ECDSA384CurveCallerSession struct {
+	Contract *ECDSA384CurveCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts        // Call options to use throughout this session
+}
+
+// ECDSA384CurveTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type ECDSA384CurveTransactorSession struct {
+	Contract     *ECDSA384CurveTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
+}
+
+// ECDSA384CurveRaw is an auto generated low-level Go binding around an Ethereum contract.
+type ECDSA384CurveRaw struct {
+	Contract *ECDSA384Curve // Generic contract binding to access the raw methods on
+}
+
+// ECDSA384CurveCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type ECDSA384CurveCallerRaw struct {
+	Contract *ECDSA384CurveCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// ECDSA384CurveTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type ECDSA384CurveTransactorRaw struct {
+	Contract *ECDSA384CurveTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewECDSA384Curve creates a new instance of ECDSA384Curve, bound to a specific deployed contract.
+func NewECDSA384Curve(address common.Address, backend bind.ContractBackend) (*ECDSA384Curve, error) {
+	contract, err := bindECDSA384Curve(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &ECDSA384Curve{ECDSA384CurveCaller: ECDSA384CurveCaller{contract: contract}, ECDSA384CurveTransactor: ECDSA384CurveTransactor{contract: contract}, ECDSA384CurveFilterer: ECDSA384CurveFilterer{contract: contract}}, nil
+}
+
+// NewECDSA384CurveCaller creates a new read-only instance of ECDSA384Curve, bound to a specific deployed contract.
+func NewECDSA384CurveCaller(address common.Address, caller bind.ContractCaller) (*ECDSA384CurveCaller, error) {
+	contract, err := bindECDSA384Curve(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ECDSA384CurveCaller{contract: contract}, nil
+}
+
+// NewECDSA384CurveTransactor creates a new write-only instance of ECDSA384Curve, bound to a specific deployed contract.
+func NewECDSA384CurveTransactor(address common.Address, transactor bind.ContractTransactor) (*ECDSA384CurveTransactor, error) {
+	contract, err := bindECDSA384Curve(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ECDSA384CurveTransactor{contract: contract}, nil
+}
+
+// NewECDSA384CurveFilterer creates a new log filterer instance of ECDSA384Curve, bound to a specific deployed contract.
+func NewECDSA384CurveFilterer(address common.Address, filterer bind.ContractFilterer) (*ECDSA384CurveFilterer, error) {
+	contract, err := bindECDSA384Curve(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &ECDSA384CurveFilterer{contract: contract}, nil
+}
+
+// bindECDSA384Curve binds a generic wrapper to an already deployed contract.
+func bindECDSA384Curve(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := ECDSA384CurveMetaData.GetAbi()
+	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 (_ECDSA384Curve *ECDSA384CurveRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _ECDSA384Curve.Contract.ECDSA384CurveCaller.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 (_ECDSA384Curve *ECDSA384CurveRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _ECDSA384Curve.Contract.ECDSA384CurveTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_ECDSA384Curve *ECDSA384CurveRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _ECDSA384Curve.Contract.ECDSA384CurveTransactor.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 (_ECDSA384Curve *ECDSA384CurveCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _ECDSA384Curve.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 (_ECDSA384Curve *ECDSA384CurveTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _ECDSA384Curve.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_ECDSA384Curve *ECDSA384CurveTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _ECDSA384Curve.Contract.contract.Transact(opts, method, params...)
+}
+
+// CURVEA is a free data retrieval call binding the contract method 0x41d36374.
+//
+// Solidity: function CURVE_A() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCaller) CURVEA(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _ECDSA384Curve.contract.Call(opts, &out, "CURVE_A")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// CURVEA is a free data retrieval call binding the contract method 0x41d36374.
+//
+// Solidity: function CURVE_A() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveSession) CURVEA() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVEA(&_ECDSA384Curve.CallOpts)
+}
+
+// CURVEA is a free data retrieval call binding the contract method 0x41d36374.
+//
+// Solidity: function CURVE_A() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCallerSession) CURVEA() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVEA(&_ECDSA384Curve.CallOpts)
+}
+
+// CURVEB is a free data retrieval call binding the contract method 0xe6e24213.
+//
+// Solidity: function CURVE_B() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCaller) CURVEB(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _ECDSA384Curve.contract.Call(opts, &out, "CURVE_B")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// CURVEB is a free data retrieval call binding the contract method 0xe6e24213.
+//
+// Solidity: function CURVE_B() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveSession) CURVEB() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVEB(&_ECDSA384Curve.CallOpts)
+}
+
+// CURVEB is a free data retrieval call binding the contract method 0xe6e24213.
+//
+// Solidity: function CURVE_B() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCallerSession) CURVEB() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVEB(&_ECDSA384Curve.CallOpts)
+}
+
+// CURVEGX is a free data retrieval call binding the contract method 0xb060c9bf.
+//
+// Solidity: function CURVE_GX() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCaller) CURVEGX(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _ECDSA384Curve.contract.Call(opts, &out, "CURVE_GX")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// CURVEGX is a free data retrieval call binding the contract method 0xb060c9bf.
+//
+// Solidity: function CURVE_GX() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveSession) CURVEGX() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVEGX(&_ECDSA384Curve.CallOpts)
+}
+
+// CURVEGX is a free data retrieval call binding the contract method 0xb060c9bf.
+//
+// Solidity: function CURVE_GX() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCallerSession) CURVEGX() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVEGX(&_ECDSA384Curve.CallOpts)
+}
+
+// CURVEGY is a free data retrieval call binding the contract method 0xa609dfc3.
+//
+// Solidity: function CURVE_GY() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCaller) CURVEGY(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _ECDSA384Curve.contract.Call(opts, &out, "CURVE_GY")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// CURVEGY is a free data retrieval call binding the contract method 0xa609dfc3.
+//
+// Solidity: function CURVE_GY() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveSession) CURVEGY() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVEGY(&_ECDSA384Curve.CallOpts)
+}
+
+// CURVEGY is a free data retrieval call binding the contract method 0xa609dfc3.
+//
+// Solidity: function CURVE_GY() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCallerSession) CURVEGY() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVEGY(&_ECDSA384Curve.CallOpts)
+}
+
+// CURVELOWSMAX is a free data retrieval call binding the contract method 0xfb3b2c8f.
+//
+// Solidity: function CURVE_LOW_S_MAX() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCaller) CURVELOWSMAX(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _ECDSA384Curve.contract.Call(opts, &out, "CURVE_LOW_S_MAX")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// CURVELOWSMAX is a free data retrieval call binding the contract method 0xfb3b2c8f.
+//
+// Solidity: function CURVE_LOW_S_MAX() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveSession) CURVELOWSMAX() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVELOWSMAX(&_ECDSA384Curve.CallOpts)
+}
+
+// CURVELOWSMAX is a free data retrieval call binding the contract method 0xfb3b2c8f.
+//
+// Solidity: function CURVE_LOW_S_MAX() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCallerSession) CURVELOWSMAX() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVELOWSMAX(&_ECDSA384Curve.CallOpts)
+}
+
+// CURVEN is a free data retrieval call binding the contract method 0xb05e505a.
+//
+// Solidity: function CURVE_N() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCaller) CURVEN(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _ECDSA384Curve.contract.Call(opts, &out, "CURVE_N")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// CURVEN is a free data retrieval call binding the contract method 0xb05e505a.
+//
+// Solidity: function CURVE_N() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveSession) CURVEN() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVEN(&_ECDSA384Curve.CallOpts)
+}
+
+// CURVEN is a free data retrieval call binding the contract method 0xb05e505a.
+//
+// Solidity: function CURVE_N() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCallerSession) CURVEN() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVEN(&_ECDSA384Curve.CallOpts)
+}
+
+// CURVEP is a free data retrieval call binding the contract method 0x7e9c58f4.
+//
+// Solidity: function CURVE_P() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCaller) CURVEP(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _ECDSA384Curve.contract.Call(opts, &out, "CURVE_P")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// CURVEP is a free data retrieval call binding the contract method 0x7e9c58f4.
+//
+// Solidity: function CURVE_P() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveSession) CURVEP() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVEP(&_ECDSA384Curve.CallOpts)
+}
+
+// CURVEP is a free data retrieval call binding the contract method 0x7e9c58f4.
+//
+// Solidity: function CURVE_P() view returns(bytes)
+func (_ECDSA384Curve *ECDSA384CurveCallerSession) CURVEP() ([]byte, error) {
+	return _ECDSA384Curve.Contract.CURVEP(&_ECDSA384Curve.CallOpts)
+}
+
+// EnclaveIdBaseMetaData contains all meta data concerning the EnclaveIdBase contract.
+var EnclaveIdBaseMetaData = &bind.MetaData{
+	ABI: "[]",
+}
+
+// EnclaveIdBaseABI is the input ABI used to generate the binding from.
+// Deprecated: Use EnclaveIdBaseMetaData.ABI instead.
+var EnclaveIdBaseABI = EnclaveIdBaseMetaData.ABI
+
+// EnclaveIdBase is an auto generated Go binding around an Ethereum contract.
+type EnclaveIdBase struct {
+	EnclaveIdBaseCaller     // Read-only binding to the contract
+	EnclaveIdBaseTransactor // Write-only binding to the contract
+	EnclaveIdBaseFilterer   // Log filterer for contract events
+}
+
+// EnclaveIdBaseCaller is an auto generated read-only Go binding around an Ethereum contract.
+type EnclaveIdBaseCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EnclaveIdBaseTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type EnclaveIdBaseTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EnclaveIdBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type EnclaveIdBaseFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EnclaveIdBaseSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type EnclaveIdBaseSession struct {
+	Contract     *EnclaveIdBase    // 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
+}
+
+// EnclaveIdBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type EnclaveIdBaseCallerSession struct {
+	Contract *EnclaveIdBaseCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts        // Call options to use throughout this session
+}
+
+// EnclaveIdBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type EnclaveIdBaseTransactorSession struct {
+	Contract     *EnclaveIdBaseTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
+}
+
+// EnclaveIdBaseRaw is an auto generated low-level Go binding around an Ethereum contract.
+type EnclaveIdBaseRaw struct {
+	Contract *EnclaveIdBase // Generic contract binding to access the raw methods on
+}
+
+// EnclaveIdBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type EnclaveIdBaseCallerRaw struct {
+	Contract *EnclaveIdBaseCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// EnclaveIdBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type EnclaveIdBaseTransactorRaw struct {
+	Contract *EnclaveIdBaseTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewEnclaveIdBase creates a new instance of EnclaveIdBase, bound to a specific deployed contract.
+func NewEnclaveIdBase(address common.Address, backend bind.ContractBackend) (*EnclaveIdBase, error) {
+	contract, err := bindEnclaveIdBase(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &EnclaveIdBase{EnclaveIdBaseCaller: EnclaveIdBaseCaller{contract: contract}, EnclaveIdBaseTransactor: EnclaveIdBaseTransactor{contract: contract}, EnclaveIdBaseFilterer: EnclaveIdBaseFilterer{contract: contract}}, nil
+}
+
+// NewEnclaveIdBaseCaller creates a new read-only instance of EnclaveIdBase, bound to a specific deployed contract.
+func NewEnclaveIdBaseCaller(address common.Address, caller bind.ContractCaller) (*EnclaveIdBaseCaller, error) {
+	contract, err := bindEnclaveIdBase(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EnclaveIdBaseCaller{contract: contract}, nil
+}
+
+// NewEnclaveIdBaseTransactor creates a new write-only instance of EnclaveIdBase, bound to a specific deployed contract.
+func NewEnclaveIdBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*EnclaveIdBaseTransactor, error) {
+	contract, err := bindEnclaveIdBase(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EnclaveIdBaseTransactor{contract: contract}, nil
+}
+
+// NewEnclaveIdBaseFilterer creates a new log filterer instance of EnclaveIdBase, bound to a specific deployed contract.
+func NewEnclaveIdBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*EnclaveIdBaseFilterer, error) {
+	contract, err := bindEnclaveIdBase(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &EnclaveIdBaseFilterer{contract: contract}, nil
+}
+
+// bindEnclaveIdBase binds a generic wrapper to an already deployed contract.
+func bindEnclaveIdBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := EnclaveIdBaseMetaData.GetAbi()
+	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 (_EnclaveIdBase *EnclaveIdBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EnclaveIdBase.Contract.EnclaveIdBaseCaller.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 (_EnclaveIdBase *EnclaveIdBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EnclaveIdBase.Contract.EnclaveIdBaseTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EnclaveIdBase *EnclaveIdBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EnclaveIdBase.Contract.EnclaveIdBaseTransactor.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 (_EnclaveIdBase *EnclaveIdBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EnclaveIdBase.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 (_EnclaveIdBase *EnclaveIdBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EnclaveIdBase.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EnclaveIdBase *EnclaveIdBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EnclaveIdBase.Contract.contract.Transact(opts, method, params...)
+}
+
+// EnclaveIdentityHelperMetaData contains all meta data concerning the EnclaveIdentityHelper contract.
+var EnclaveIdentityHelperMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"identityStr\",\"type\":\"string\"}],\"name\":\"parseIdentityString\",\"outputs\":[{\"components\":[{\"internalType\":\"enumEnclaveId\",\"name\":\"id\",\"type\":\"uint8\"},{\"internalType\":\"uint32\",\"name\":\"version\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"issueDateTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"nextUpdateTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint32\",\"name\":\"tcbEvaluationDataNumber\",\"type\":\"uint32\"},{\"internalType\":\"bytes4\",\"name\":\"miscselect\",\"type\":\"bytes4\"},{\"internalType\":\"bytes4\",\"name\":\"miscselectMask\",\"type\":\"bytes4\"},{\"internalType\":\"bytes16\",\"name\":\"attributes\",\"type\":\"bytes16\"},{\"internalType\":\"bytes16\",\"name\":\"attributesMask\",\"type\":\"bytes16\"},{\"internalType\":\"bytes32\",\"name\":\"mrsigner\",\"type\":\"bytes32\"},{\"internalType\":\"uint16\",\"name\":\"isvprodid\",\"type\":\"uint16\"},{\"components\":[{\"internalType\":\"uint16\",\"name\":\"isvsvn\",\"type\":\"uint16\"},{\"internalType\":\"uint256\",\"name\":\"dateTimestamp\",\"type\":\"uint256\"},{\"internalType\":\"enumEnclaveIdTcbStatus\",\"name\":\"status\",\"type\":\"uint8\"}],\"internalType\":\"structTcb[]\",\"name\":\"tcb\",\"type\":\"tuple[]\"}],\"internalType\":\"structIdentityObj\",\"name\":\"identity\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"Invalid_ID\",\"type\":\"error\"}]",
+	Bin: "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",
+}
+
+// EnclaveIdentityHelperABI is the input ABI used to generate the binding from.
+// Deprecated: Use EnclaveIdentityHelperMetaData.ABI instead.
+var EnclaveIdentityHelperABI = EnclaveIdentityHelperMetaData.ABI
+
+// EnclaveIdentityHelperBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use EnclaveIdentityHelperMetaData.Bin instead.
+var EnclaveIdentityHelperBin = EnclaveIdentityHelperMetaData.Bin
+
+// DeployEnclaveIdentityHelper deploys a new Ethereum contract, binding an instance of EnclaveIdentityHelper to it.
+func DeployEnclaveIdentityHelper(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *EnclaveIdentityHelper, error) {
+	parsed, err := EnclaveIdentityHelperMetaData.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(EnclaveIdentityHelperBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &EnclaveIdentityHelper{EnclaveIdentityHelperCaller: EnclaveIdentityHelperCaller{contract: contract}, EnclaveIdentityHelperTransactor: EnclaveIdentityHelperTransactor{contract: contract}, EnclaveIdentityHelperFilterer: EnclaveIdentityHelperFilterer{contract: contract}}, nil
+}
+
+// EnclaveIdentityHelper is an auto generated Go binding around an Ethereum contract.
+type EnclaveIdentityHelper struct {
+	EnclaveIdentityHelperCaller     // Read-only binding to the contract
+	EnclaveIdentityHelperTransactor // Write-only binding to the contract
+	EnclaveIdentityHelperFilterer   // Log filterer for contract events
+}
+
+// EnclaveIdentityHelperCaller is an auto generated read-only Go binding around an Ethereum contract.
+type EnclaveIdentityHelperCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EnclaveIdentityHelperTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type EnclaveIdentityHelperTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EnclaveIdentityHelperFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type EnclaveIdentityHelperFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EnclaveIdentityHelperSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type EnclaveIdentityHelperSession struct {
+	Contract     *EnclaveIdentityHelper // 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
+}
+
+// EnclaveIdentityHelperCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type EnclaveIdentityHelperCallerSession struct {
+	Contract *EnclaveIdentityHelperCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts                // Call options to use throughout this session
+}
+
+// EnclaveIdentityHelperTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type EnclaveIdentityHelperTransactorSession struct {
+	Contract     *EnclaveIdentityHelperTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts                // Transaction auth options to use throughout this session
+}
+
+// EnclaveIdentityHelperRaw is an auto generated low-level Go binding around an Ethereum contract.
+type EnclaveIdentityHelperRaw struct {
+	Contract *EnclaveIdentityHelper // Generic contract binding to access the raw methods on
+}
+
+// EnclaveIdentityHelperCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type EnclaveIdentityHelperCallerRaw struct {
+	Contract *EnclaveIdentityHelperCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// EnclaveIdentityHelperTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type EnclaveIdentityHelperTransactorRaw struct {
+	Contract *EnclaveIdentityHelperTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewEnclaveIdentityHelper creates a new instance of EnclaveIdentityHelper, bound to a specific deployed contract.
+func NewEnclaveIdentityHelper(address common.Address, backend bind.ContractBackend) (*EnclaveIdentityHelper, error) {
+	contract, err := bindEnclaveIdentityHelper(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &EnclaveIdentityHelper{EnclaveIdentityHelperCaller: EnclaveIdentityHelperCaller{contract: contract}, EnclaveIdentityHelperTransactor: EnclaveIdentityHelperTransactor{contract: contract}, EnclaveIdentityHelperFilterer: EnclaveIdentityHelperFilterer{contract: contract}}, nil
+}
+
+// NewEnclaveIdentityHelperCaller creates a new read-only instance of EnclaveIdentityHelper, bound to a specific deployed contract.
+func NewEnclaveIdentityHelperCaller(address common.Address, caller bind.ContractCaller) (*EnclaveIdentityHelperCaller, error) {
+	contract, err := bindEnclaveIdentityHelper(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EnclaveIdentityHelperCaller{contract: contract}, nil
+}
+
+// NewEnclaveIdentityHelperTransactor creates a new write-only instance of EnclaveIdentityHelper, bound to a specific deployed contract.
+func NewEnclaveIdentityHelperTransactor(address common.Address, transactor bind.ContractTransactor) (*EnclaveIdentityHelperTransactor, error) {
+	contract, err := bindEnclaveIdentityHelper(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EnclaveIdentityHelperTransactor{contract: contract}, nil
+}
+
+// NewEnclaveIdentityHelperFilterer creates a new log filterer instance of EnclaveIdentityHelper, bound to a specific deployed contract.
+func NewEnclaveIdentityHelperFilterer(address common.Address, filterer bind.ContractFilterer) (*EnclaveIdentityHelperFilterer, error) {
+	contract, err := bindEnclaveIdentityHelper(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &EnclaveIdentityHelperFilterer{contract: contract}, nil
+}
+
+// bindEnclaveIdentityHelper binds a generic wrapper to an already deployed contract.
+func bindEnclaveIdentityHelper(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := EnclaveIdentityHelperMetaData.GetAbi()
+	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 (_EnclaveIdentityHelper *EnclaveIdentityHelperRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EnclaveIdentityHelper.Contract.EnclaveIdentityHelperCaller.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 (_EnclaveIdentityHelper *EnclaveIdentityHelperRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EnclaveIdentityHelper.Contract.EnclaveIdentityHelperTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EnclaveIdentityHelper *EnclaveIdentityHelperRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EnclaveIdentityHelper.Contract.EnclaveIdentityHelperTransactor.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 (_EnclaveIdentityHelper *EnclaveIdentityHelperCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EnclaveIdentityHelper.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 (_EnclaveIdentityHelper *EnclaveIdentityHelperTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EnclaveIdentityHelper.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EnclaveIdentityHelper *EnclaveIdentityHelperTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EnclaveIdentityHelper.Contract.contract.Transact(opts, method, params...)
+}
+
+// ParseIdentityString is a free data retrieval call binding the contract method 0xc0ed9773.
+//
+// Solidity: function parseIdentityString(string identityStr) pure returns((uint8,uint32,uint64,uint64,uint32,bytes4,bytes4,bytes16,bytes16,bytes32,uint16,(uint16,uint256,uint8)[]) identity)
+func (_EnclaveIdentityHelper *EnclaveIdentityHelperCaller) ParseIdentityString(opts *bind.CallOpts, identityStr string) (IdentityObj, error) {
+	var out []interface{}
+	err := _EnclaveIdentityHelper.contract.Call(opts, &out, "parseIdentityString", identityStr)
+
+	if err != nil {
+		return *new(IdentityObj), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(IdentityObj)).(*IdentityObj)
+
+	return out0, err
+
+}
+
+// ParseIdentityString is a free data retrieval call binding the contract method 0xc0ed9773.
+//
+// Solidity: function parseIdentityString(string identityStr) pure returns((uint8,uint32,uint64,uint64,uint32,bytes4,bytes4,bytes16,bytes16,bytes32,uint16,(uint16,uint256,uint8)[]) identity)
+func (_EnclaveIdentityHelper *EnclaveIdentityHelperSession) ParseIdentityString(identityStr string) (IdentityObj, error) {
+	return _EnclaveIdentityHelper.Contract.ParseIdentityString(&_EnclaveIdentityHelper.CallOpts, identityStr)
+}
+
+// ParseIdentityString is a free data retrieval call binding the contract method 0xc0ed9773.
+//
+// Solidity: function parseIdentityString(string identityStr) pure returns((uint8,uint32,uint64,uint64,uint32,bytes4,bytes4,bytes16,bytes16,bytes32,uint16,(uint16,uint256,uint8)[]) identity)
+func (_EnclaveIdentityHelper *EnclaveIdentityHelperCallerSession) ParseIdentityString(identityStr string) (IdentityObj, error) {
+	return _EnclaveIdentityHelper.Contract.ParseIdentityString(&_EnclaveIdentityHelper.CallOpts, identityStr)
+}
+
+// EspressoNitroTEEVerifierMetaData contains all meta data concerning the EspressoNitroTEEVerifier contract.
+var EspressoNitroTEEVerifierMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"},{\"internalType\":\"contractCertManager\",\"name\":\"certManager\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ATTESTATION_DIGEST\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ATTESTATION_TBS_PREFIX\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CABUNDLE_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CERTIFICATE_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DIGEST_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MODULE_ID_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"NONCE_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PCRS_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PUBLIC_KEY_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"TIMESTAMP_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"USER_DATA_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"certManager\",\"outputs\":[{\"internalType\":\"contractICertManager\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"certHash\",\"type\":\"bytes32\"}],\"name\":\"certVerified\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"attestation\",\"type\":\"bytes\"}],\"name\":\"decodeAttestationTbs\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"attestationTbs\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"signers\",\"type\":\"address[]\"}],\"name\":\"deleteRegisteredSigners\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"attestation\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"registerSigner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"registeredEnclaveHash\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"registeredSigners\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"},{\"internalType\":\"bool\",\"name\":\"valid\",\"type\":\"bool\"}],\"name\":\"setEnclaveHash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"attestationTbs\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"validateAttestation\",\"outputs\":[{\"components\":[{\"internalType\":\"CborElement\",\"name\":\"moduleID\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"timestamp\",\"type\":\"uint64\"},{\"internalType\":\"CborElement\",\"name\":\"digest\",\"type\":\"uint256\"},{\"internalType\":\"CborElement[]\",\"name\":\"pcrs\",\"type\":\"uint256[]\"},{\"internalType\":\"CborElement\",\"name\":\"cert\",\"type\":\"uint256\"},{\"internalType\":\"CborElement[]\",\"name\":\"cabundle\",\"type\":\"uint256[]\"},{\"internalType\":\"CborElement\",\"name\":\"publicKey\",\"type\":\"uint256\"},{\"internalType\":\"CborElement\",\"name\":\"userData\",\"type\":\"uint256\"},{\"internalType\":\"CborElement\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"internalType\":\"structNitroValidator.Ptrs\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"certificate\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"parentCertHash\",\"type\":\"bytes32\"}],\"name\":\"verifyCACert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"certificate\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"parentCertHash\",\"type\":\"bytes32\"}],\"name\":\"verifyClientCert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"valid\",\"type\":\"bool\"}],\"name\":\"AWSEnclaveHashSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"}],\"name\":\"AWSSignerRegistered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"DeletedAWSRegisteredSigner\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"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\":\"InvalidAWSEnclaveHash\",\"type\":\"error\"}]",
+	Bin: "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",
+}
+
+// EspressoNitroTEEVerifierABI is the input ABI used to generate the binding from.
+// Deprecated: Use EspressoNitroTEEVerifierMetaData.ABI instead.
+var EspressoNitroTEEVerifierABI = EspressoNitroTEEVerifierMetaData.ABI
+
+// EspressoNitroTEEVerifierBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use EspressoNitroTEEVerifierMetaData.Bin instead.
+var EspressoNitroTEEVerifierBin = EspressoNitroTEEVerifierMetaData.Bin
+
+// DeployEspressoNitroTEEVerifier deploys a new Ethereum contract, binding an instance of EspressoNitroTEEVerifier to it.
+func DeployEspressoNitroTEEVerifier(auth *bind.TransactOpts, backend bind.ContractBackend, enclaveHash [32]byte, certManager common.Address) (common.Address, *types.Transaction, *EspressoNitroTEEVerifier, error) {
+	parsed, err := EspressoNitroTEEVerifierMetaData.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(EspressoNitroTEEVerifierBin), backend, enclaveHash, certManager)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &EspressoNitroTEEVerifier{EspressoNitroTEEVerifierCaller: EspressoNitroTEEVerifierCaller{contract: contract}, EspressoNitroTEEVerifierTransactor: EspressoNitroTEEVerifierTransactor{contract: contract}, EspressoNitroTEEVerifierFilterer: EspressoNitroTEEVerifierFilterer{contract: contract}}, nil
+}
+
+// EspressoNitroTEEVerifier is an auto generated Go binding around an Ethereum contract.
+type EspressoNitroTEEVerifier struct {
+	EspressoNitroTEEVerifierCaller     // Read-only binding to the contract
+	EspressoNitroTEEVerifierTransactor // Write-only binding to the contract
+	EspressoNitroTEEVerifierFilterer   // Log filterer for contract events
+}
+
+// EspressoNitroTEEVerifierCaller is an auto generated read-only Go binding around an Ethereum contract.
+type EspressoNitroTEEVerifierCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoNitroTEEVerifierTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type EspressoNitroTEEVerifierTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoNitroTEEVerifierFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type EspressoNitroTEEVerifierFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoNitroTEEVerifierSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type EspressoNitroTEEVerifierSession struct {
+	Contract     *EspressoNitroTEEVerifier // 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
+}
+
+// EspressoNitroTEEVerifierCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type EspressoNitroTEEVerifierCallerSession struct {
+	Contract *EspressoNitroTEEVerifierCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts                   // Call options to use throughout this session
+}
+
+// EspressoNitroTEEVerifierTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type EspressoNitroTEEVerifierTransactorSession struct {
+	Contract     *EspressoNitroTEEVerifierTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts                   // Transaction auth options to use throughout this session
+}
+
+// EspressoNitroTEEVerifierRaw is an auto generated low-level Go binding around an Ethereum contract.
+type EspressoNitroTEEVerifierRaw struct {
+	Contract *EspressoNitroTEEVerifier // Generic contract binding to access the raw methods on
+}
+
+// EspressoNitroTEEVerifierCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type EspressoNitroTEEVerifierCallerRaw struct {
+	Contract *EspressoNitroTEEVerifierCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// EspressoNitroTEEVerifierTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type EspressoNitroTEEVerifierTransactorRaw struct {
+	Contract *EspressoNitroTEEVerifierTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewEspressoNitroTEEVerifier creates a new instance of EspressoNitroTEEVerifier, bound to a specific deployed contract.
+func NewEspressoNitroTEEVerifier(address common.Address, backend bind.ContractBackend) (*EspressoNitroTEEVerifier, error) {
+	contract, err := bindEspressoNitroTEEVerifier(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifier{EspressoNitroTEEVerifierCaller: EspressoNitroTEEVerifierCaller{contract: contract}, EspressoNitroTEEVerifierTransactor: EspressoNitroTEEVerifierTransactor{contract: contract}, EspressoNitroTEEVerifierFilterer: EspressoNitroTEEVerifierFilterer{contract: contract}}, nil
+}
+
+// NewEspressoNitroTEEVerifierCaller creates a new read-only instance of EspressoNitroTEEVerifier, bound to a specific deployed contract.
+func NewEspressoNitroTEEVerifierCaller(address common.Address, caller bind.ContractCaller) (*EspressoNitroTEEVerifierCaller, error) {
+	contract, err := bindEspressoNitroTEEVerifier(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierCaller{contract: contract}, nil
+}
+
+// NewEspressoNitroTEEVerifierTransactor creates a new write-only instance of EspressoNitroTEEVerifier, bound to a specific deployed contract.
+func NewEspressoNitroTEEVerifierTransactor(address common.Address, transactor bind.ContractTransactor) (*EspressoNitroTEEVerifierTransactor, error) {
+	contract, err := bindEspressoNitroTEEVerifier(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTransactor{contract: contract}, nil
+}
+
+// NewEspressoNitroTEEVerifierFilterer creates a new log filterer instance of EspressoNitroTEEVerifier, bound to a specific deployed contract.
+func NewEspressoNitroTEEVerifierFilterer(address common.Address, filterer bind.ContractFilterer) (*EspressoNitroTEEVerifierFilterer, error) {
+	contract, err := bindEspressoNitroTEEVerifier(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierFilterer{contract: contract}, nil
+}
+
+// bindEspressoNitroTEEVerifier binds a generic wrapper to an already deployed contract.
+func bindEspressoNitroTEEVerifier(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := EspressoNitroTEEVerifierMetaData.GetAbi()
+	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 (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoNitroTEEVerifier.Contract.EspressoNitroTEEVerifierCaller.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 (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.EspressoNitroTEEVerifierTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.EspressoNitroTEEVerifierTransactor.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 (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoNitroTEEVerifier.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 (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.contract.Transact(opts, method, params...)
+}
+
+// ATTESTATIONDIGEST is a free data retrieval call binding the contract method 0x3893af6d.
+//
+// Solidity: function ATTESTATION_DIGEST() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) ATTESTATIONDIGEST(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "ATTESTATION_DIGEST")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// ATTESTATIONDIGEST is a free data retrieval call binding the contract method 0x3893af6d.
+//
+// Solidity: function ATTESTATION_DIGEST() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) ATTESTATIONDIGEST() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.ATTESTATIONDIGEST(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// ATTESTATIONDIGEST is a free data retrieval call binding the contract method 0x3893af6d.
+//
+// Solidity: function ATTESTATION_DIGEST() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) ATTESTATIONDIGEST() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.ATTESTATIONDIGEST(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// ATTESTATIONTBSPREFIX is a free data retrieval call binding the contract method 0x2d4bad8a.
+//
+// Solidity: function ATTESTATION_TBS_PREFIX() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) ATTESTATIONTBSPREFIX(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "ATTESTATION_TBS_PREFIX")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// ATTESTATIONTBSPREFIX is a free data retrieval call binding the contract method 0x2d4bad8a.
+//
+// Solidity: function ATTESTATION_TBS_PREFIX() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) ATTESTATIONTBSPREFIX() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.ATTESTATIONTBSPREFIX(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// ATTESTATIONTBSPREFIX is a free data retrieval call binding the contract method 0x2d4bad8a.
+//
+// Solidity: function ATTESTATION_TBS_PREFIX() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) ATTESTATIONTBSPREFIX() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.ATTESTATIONTBSPREFIX(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// CABUNDLEKEY is a free data retrieval call binding the contract method 0x9cc3eb48.
+//
+// Solidity: function CABUNDLE_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) CABUNDLEKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "CABUNDLE_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// CABUNDLEKEY is a free data retrieval call binding the contract method 0x9cc3eb48.
+//
+// Solidity: function CABUNDLE_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) CABUNDLEKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.CABUNDLEKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// CABUNDLEKEY is a free data retrieval call binding the contract method 0x9cc3eb48.
+//
+// Solidity: function CABUNDLE_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) CABUNDLEKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.CABUNDLEKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// CERTIFICATEKEY is a free data retrieval call binding the contract method 0xae951149.
+//
+// Solidity: function CERTIFICATE_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) CERTIFICATEKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "CERTIFICATE_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// CERTIFICATEKEY is a free data retrieval call binding the contract method 0xae951149.
+//
+// Solidity: function CERTIFICATE_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) CERTIFICATEKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.CERTIFICATEKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// CERTIFICATEKEY is a free data retrieval call binding the contract method 0xae951149.
+//
+// Solidity: function CERTIFICATE_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) CERTIFICATEKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.CERTIFICATEKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// DIGESTKEY is a free data retrieval call binding the contract method 0x6be1e68b.
+//
+// Solidity: function DIGEST_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) DIGESTKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "DIGEST_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// DIGESTKEY is a free data retrieval call binding the contract method 0x6be1e68b.
+//
+// Solidity: function DIGEST_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) DIGESTKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.DIGESTKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// DIGESTKEY is a free data retrieval call binding the contract method 0x6be1e68b.
+//
+// Solidity: function DIGEST_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) DIGESTKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.DIGESTKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// MODULEIDKEY is a free data retrieval call binding the contract method 0x9adb2d68.
+//
+// Solidity: function MODULE_ID_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) MODULEIDKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "MODULE_ID_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// MODULEIDKEY is a free data retrieval call binding the contract method 0x9adb2d68.
+//
+// Solidity: function MODULE_ID_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) MODULEIDKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.MODULEIDKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// MODULEIDKEY is a free data retrieval call binding the contract method 0x9adb2d68.
+//
+// Solidity: function MODULE_ID_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) MODULEIDKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.MODULEIDKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// NONCEKEY is a free data retrieval call binding the contract method 0x6378aad5.
+//
+// Solidity: function NONCE_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) NONCEKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "NONCE_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// NONCEKEY is a free data retrieval call binding the contract method 0x6378aad5.
+//
+// Solidity: function NONCE_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) NONCEKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.NONCEKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// NONCEKEY is a free data retrieval call binding the contract method 0x6378aad5.
+//
+// Solidity: function NONCE_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) NONCEKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.NONCEKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// PCRSKEY is a free data retrieval call binding the contract method 0xb22bed7e.
+//
+// Solidity: function PCRS_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) PCRSKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "PCRS_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// PCRSKEY is a free data retrieval call binding the contract method 0xb22bed7e.
+//
+// Solidity: function PCRS_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) PCRSKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.PCRSKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// PCRSKEY is a free data retrieval call binding the contract method 0xb22bed7e.
+//
+// Solidity: function PCRS_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) PCRSKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.PCRSKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// PUBLICKEYKEY is a free data retrieval call binding the contract method 0xe8b6d3fe.
+//
+// Solidity: function PUBLIC_KEY_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) PUBLICKEYKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "PUBLIC_KEY_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// PUBLICKEYKEY is a free data retrieval call binding the contract method 0xe8b6d3fe.
+//
+// Solidity: function PUBLIC_KEY_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) PUBLICKEYKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.PUBLICKEYKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// PUBLICKEYKEY is a free data retrieval call binding the contract method 0xe8b6d3fe.
+//
+// Solidity: function PUBLIC_KEY_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) PUBLICKEYKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.PUBLICKEYKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// TIMESTAMPKEY is a free data retrieval call binding the contract method 0xe0a655ff.
+//
+// Solidity: function TIMESTAMP_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) TIMESTAMPKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "TIMESTAMP_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// TIMESTAMPKEY is a free data retrieval call binding the contract method 0xe0a655ff.
+//
+// Solidity: function TIMESTAMP_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) TIMESTAMPKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.TIMESTAMPKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// TIMESTAMPKEY is a free data retrieval call binding the contract method 0xe0a655ff.
+//
+// Solidity: function TIMESTAMP_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) TIMESTAMPKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.TIMESTAMPKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// USERDATAKEY is a free data retrieval call binding the contract method 0xcebf08d7.
+//
+// Solidity: function USER_DATA_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) USERDATAKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "USER_DATA_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// USERDATAKEY is a free data retrieval call binding the contract method 0xcebf08d7.
+//
+// Solidity: function USER_DATA_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) USERDATAKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.USERDATAKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// USERDATAKEY is a free data retrieval call binding the contract method 0xcebf08d7.
+//
+// Solidity: function USER_DATA_KEY() view returns(bytes32)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) USERDATAKEY() ([32]byte, error) {
+	return _EspressoNitroTEEVerifier.Contract.USERDATAKEY(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// CertManager is a free data retrieval call binding the contract method 0x739e8484.
+//
+// Solidity: function certManager() view returns(address)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) CertManager(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "certManager")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// CertManager is a free data retrieval call binding the contract method 0x739e8484.
+//
+// Solidity: function certManager() view returns(address)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) CertManager() (common.Address, error) {
+	return _EspressoNitroTEEVerifier.Contract.CertManager(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// CertManager is a free data retrieval call binding the contract method 0x739e8484.
+//
+// Solidity: function certManager() view returns(address)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) CertManager() (common.Address, error) {
+	return _EspressoNitroTEEVerifier.Contract.CertManager(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// CertVerified is a free data retrieval call binding the contract method 0x676d1daa.
+//
+// Solidity: function certVerified(bytes32 certHash) view returns(bool)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) CertVerified(opts *bind.CallOpts, certHash [32]byte) (bool, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "certVerified", certHash)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// CertVerified is a free data retrieval call binding the contract method 0x676d1daa.
+//
+// Solidity: function certVerified(bytes32 certHash) view returns(bool)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) CertVerified(certHash [32]byte) (bool, error) {
+	return _EspressoNitroTEEVerifier.Contract.CertVerified(&_EspressoNitroTEEVerifier.CallOpts, certHash)
+}
+
+// CertVerified is a free data retrieval call binding the contract method 0x676d1daa.
+//
+// Solidity: function certVerified(bytes32 certHash) view returns(bool)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) CertVerified(certHash [32]byte) (bool, error) {
+	return _EspressoNitroTEEVerifier.Contract.CertVerified(&_EspressoNitroTEEVerifier.CallOpts, certHash)
+}
+
+// DecodeAttestationTbs is a free data retrieval call binding the contract method 0xa903a277.
+//
+// Solidity: function decodeAttestationTbs(bytes attestation) pure returns(bytes attestationTbs, bytes signature)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) DecodeAttestationTbs(opts *bind.CallOpts, attestation []byte) (struct {
+	AttestationTbs []byte
+	Signature      []byte
+}, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "decodeAttestationTbs", attestation)
+
+	outstruct := new(struct {
+		AttestationTbs []byte
+		Signature      []byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.AttestationTbs = *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+	outstruct.Signature = *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return *outstruct, err
+
+}
+
+// DecodeAttestationTbs is a free data retrieval call binding the contract method 0xa903a277.
+//
+// Solidity: function decodeAttestationTbs(bytes attestation) pure returns(bytes attestationTbs, bytes signature)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) DecodeAttestationTbs(attestation []byte) (struct {
+	AttestationTbs []byte
+	Signature      []byte
+}, error) {
+	return _EspressoNitroTEEVerifier.Contract.DecodeAttestationTbs(&_EspressoNitroTEEVerifier.CallOpts, attestation)
+}
+
+// DecodeAttestationTbs is a free data retrieval call binding the contract method 0xa903a277.
+//
+// Solidity: function decodeAttestationTbs(bytes attestation) pure returns(bytes attestationTbs, bytes signature)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) DecodeAttestationTbs(attestation []byte) (struct {
+	AttestationTbs []byte
+	Signature      []byte
+}, error) {
+	return _EspressoNitroTEEVerifier.Contract.DecodeAttestationTbs(&_EspressoNitroTEEVerifier.CallOpts, attestation)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.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 (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) Owner() (common.Address, error) {
+	return _EspressoNitroTEEVerifier.Contract.Owner(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) Owner() (common.Address, error) {
+	return _EspressoNitroTEEVerifier.Contract.Owner(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) PendingOwner(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "pendingOwner")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) PendingOwner() (common.Address, error) {
+	return _EspressoNitroTEEVerifier.Contract.PendingOwner(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) PendingOwner() (common.Address, error) {
+	return _EspressoNitroTEEVerifier.Contract.PendingOwner(&_EspressoNitroTEEVerifier.CallOpts)
+}
+
+// RegisteredEnclaveHash is a free data retrieval call binding the contract method 0x966989ee.
+//
+// Solidity: function registeredEnclaveHash(bytes32 ) view returns(bool)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) RegisteredEnclaveHash(opts *bind.CallOpts, arg0 [32]byte) (bool, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "registeredEnclaveHash", arg0)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredEnclaveHash is a free data retrieval call binding the contract method 0x966989ee.
+//
+// Solidity: function registeredEnclaveHash(bytes32 ) view returns(bool)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) RegisteredEnclaveHash(arg0 [32]byte) (bool, error) {
+	return _EspressoNitroTEEVerifier.Contract.RegisteredEnclaveHash(&_EspressoNitroTEEVerifier.CallOpts, arg0)
+}
+
+// RegisteredEnclaveHash is a free data retrieval call binding the contract method 0x966989ee.
+//
+// Solidity: function registeredEnclaveHash(bytes32 ) view returns(bool)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) RegisteredEnclaveHash(arg0 [32]byte) (bool, error) {
+	return _EspressoNitroTEEVerifier.Contract.RegisteredEnclaveHash(&_EspressoNitroTEEVerifier.CallOpts, arg0)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0x0123d0c1.
+//
+// Solidity: function registeredSigners(address ) view returns(bool)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCaller) RegisteredSigners(opts *bind.CallOpts, arg0 common.Address) (bool, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifier.contract.Call(opts, &out, "registeredSigners", arg0)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0x0123d0c1.
+//
+// Solidity: function registeredSigners(address ) view returns(bool)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) RegisteredSigners(arg0 common.Address) (bool, error) {
+	return _EspressoNitroTEEVerifier.Contract.RegisteredSigners(&_EspressoNitroTEEVerifier.CallOpts, arg0)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0x0123d0c1.
+//
+// Solidity: function registeredSigners(address ) view returns(bool)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierCallerSession) RegisteredSigners(arg0 common.Address) (bool, error) {
+	return _EspressoNitroTEEVerifier.Contract.RegisteredSigners(&_EspressoNitroTEEVerifier.CallOpts, arg0)
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactor) AcceptOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.contract.Transact(opts, "acceptOwnership")
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) AcceptOwnership() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.AcceptOwnership(&_EspressoNitroTEEVerifier.TransactOpts)
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactorSession) AcceptOwnership() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.AcceptOwnership(&_EspressoNitroTEEVerifier.TransactOpts)
+}
+
+// DeleteRegisteredSigners is a paid mutator transaction binding the contract method 0xe7370be0.
+//
+// Solidity: function deleteRegisteredSigners(address[] signers) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactor) DeleteRegisteredSigners(opts *bind.TransactOpts, signers []common.Address) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.contract.Transact(opts, "deleteRegisteredSigners", signers)
+}
+
+// DeleteRegisteredSigners is a paid mutator transaction binding the contract method 0xe7370be0.
+//
+// Solidity: function deleteRegisteredSigners(address[] signers) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) DeleteRegisteredSigners(signers []common.Address) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.DeleteRegisteredSigners(&_EspressoNitroTEEVerifier.TransactOpts, signers)
+}
+
+// DeleteRegisteredSigners is a paid mutator transaction binding the contract method 0xe7370be0.
+//
+// Solidity: function deleteRegisteredSigners(address[] signers) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactorSession) DeleteRegisteredSigners(signers []common.Address) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.DeleteRegisteredSigners(&_EspressoNitroTEEVerifier.TransactOpts, signers)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0xba58e82a.
+//
+// Solidity: function registerSigner(bytes attestation, bytes signature) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactor) RegisterSigner(opts *bind.TransactOpts, attestation []byte, signature []byte) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.contract.Transact(opts, "registerSigner", attestation, signature)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0xba58e82a.
+//
+// Solidity: function registerSigner(bytes attestation, bytes signature) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) RegisterSigner(attestation []byte, signature []byte) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.RegisterSigner(&_EspressoNitroTEEVerifier.TransactOpts, attestation, signature)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0xba58e82a.
+//
+// Solidity: function registerSigner(bytes attestation, bytes signature) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactorSession) RegisterSigner(attestation []byte, signature []byte) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.RegisterSigner(&_EspressoNitroTEEVerifier.TransactOpts, attestation, signature)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.contract.Transact(opts, "renounceOwnership")
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) RenounceOwnership() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.RenounceOwnership(&_EspressoNitroTEEVerifier.TransactOpts)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactorSession) RenounceOwnership() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.RenounceOwnership(&_EspressoNitroTEEVerifier.TransactOpts)
+}
+
+// SetEnclaveHash is a paid mutator transaction binding the contract method 0x93b5552e.
+//
+// Solidity: function setEnclaveHash(bytes32 enclaveHash, bool valid) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactor) SetEnclaveHash(opts *bind.TransactOpts, enclaveHash [32]byte, valid bool) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.contract.Transact(opts, "setEnclaveHash", enclaveHash, valid)
+}
+
+// SetEnclaveHash is a paid mutator transaction binding the contract method 0x93b5552e.
+//
+// Solidity: function setEnclaveHash(bytes32 enclaveHash, bool valid) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) SetEnclaveHash(enclaveHash [32]byte, valid bool) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.SetEnclaveHash(&_EspressoNitroTEEVerifier.TransactOpts, enclaveHash, valid)
+}
+
+// SetEnclaveHash is a paid mutator transaction binding the contract method 0x93b5552e.
+//
+// Solidity: function setEnclaveHash(bytes32 enclaveHash, bool valid) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactorSession) SetEnclaveHash(enclaveHash [32]byte, valid bool) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.SetEnclaveHash(&_EspressoNitroTEEVerifier.TransactOpts, enclaveHash, valid)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.contract.Transact(opts, "transferOwnership", newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.TransferOwnership(&_EspressoNitroTEEVerifier.TransactOpts, newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.TransferOwnership(&_EspressoNitroTEEVerifier.TransactOpts, newOwner)
+}
+
+// ValidateAttestation is a paid mutator transaction binding the contract method 0x05f7aead.
+//
+// Solidity: function validateAttestation(bytes attestationTbs, bytes signature) returns((uint256,uint64,uint256,uint256[],uint256,uint256[],uint256,uint256,uint256))
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactor) ValidateAttestation(opts *bind.TransactOpts, attestationTbs []byte, signature []byte) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.contract.Transact(opts, "validateAttestation", attestationTbs, signature)
+}
+
+// ValidateAttestation is a paid mutator transaction binding the contract method 0x05f7aead.
+//
+// Solidity: function validateAttestation(bytes attestationTbs, bytes signature) returns((uint256,uint64,uint256,uint256[],uint256,uint256[],uint256,uint256,uint256))
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) ValidateAttestation(attestationTbs []byte, signature []byte) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.ValidateAttestation(&_EspressoNitroTEEVerifier.TransactOpts, attestationTbs, signature)
+}
+
+// ValidateAttestation is a paid mutator transaction binding the contract method 0x05f7aead.
+//
+// Solidity: function validateAttestation(bytes attestationTbs, bytes signature) returns((uint256,uint64,uint256,uint256[],uint256,uint256[],uint256,uint256,uint256))
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactorSession) ValidateAttestation(attestationTbs []byte, signature []byte) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.ValidateAttestation(&_EspressoNitroTEEVerifier.TransactOpts, attestationTbs, signature)
+}
+
+// VerifyCACert is a paid mutator transaction binding the contract method 0x0890702c.
+//
+// Solidity: function verifyCACert(bytes certificate, bytes32 parentCertHash) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactor) VerifyCACert(opts *bind.TransactOpts, certificate []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.contract.Transact(opts, "verifyCACert", certificate, parentCertHash)
+}
+
+// VerifyCACert is a paid mutator transaction binding the contract method 0x0890702c.
+//
+// Solidity: function verifyCACert(bytes certificate, bytes32 parentCertHash) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) VerifyCACert(certificate []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.VerifyCACert(&_EspressoNitroTEEVerifier.TransactOpts, certificate, parentCertHash)
+}
+
+// VerifyCACert is a paid mutator transaction binding the contract method 0x0890702c.
+//
+// Solidity: function verifyCACert(bytes certificate, bytes32 parentCertHash) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactorSession) VerifyCACert(certificate []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.VerifyCACert(&_EspressoNitroTEEVerifier.TransactOpts, certificate, parentCertHash)
+}
+
+// VerifyClientCert is a paid mutator transaction binding the contract method 0x28c54637.
+//
+// Solidity: function verifyClientCert(bytes certificate, bytes32 parentCertHash) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactor) VerifyClientCert(opts *bind.TransactOpts, certificate []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.contract.Transact(opts, "verifyClientCert", certificate, parentCertHash)
+}
+
+// VerifyClientCert is a paid mutator transaction binding the contract method 0x28c54637.
+//
+// Solidity: function verifyClientCert(bytes certificate, bytes32 parentCertHash) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierSession) VerifyClientCert(certificate []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.VerifyClientCert(&_EspressoNitroTEEVerifier.TransactOpts, certificate, parentCertHash)
+}
+
+// VerifyClientCert is a paid mutator transaction binding the contract method 0x28c54637.
+//
+// Solidity: function verifyClientCert(bytes certificate, bytes32 parentCertHash) returns()
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierTransactorSession) VerifyClientCert(certificate []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifier.Contract.VerifyClientCert(&_EspressoNitroTEEVerifier.TransactOpts, certificate, parentCertHash)
+}
+
+// EspressoNitroTEEVerifierAWSEnclaveHashSetIterator is returned from FilterAWSEnclaveHashSet and is used to iterate over the raw logs and unpacked data for AWSEnclaveHashSet events raised by the EspressoNitroTEEVerifier contract.
+type EspressoNitroTEEVerifierAWSEnclaveHashSetIterator struct {
+	Event *EspressoNitroTEEVerifierAWSEnclaveHashSet // 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 *EspressoNitroTEEVerifierAWSEnclaveHashSetIterator) 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(EspressoNitroTEEVerifierAWSEnclaveHashSet)
+			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(EspressoNitroTEEVerifierAWSEnclaveHashSet)
+		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 *EspressoNitroTEEVerifierAWSEnclaveHashSetIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierAWSEnclaveHashSetIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierAWSEnclaveHashSet represents a AWSEnclaveHashSet event raised by the EspressoNitroTEEVerifier contract.
+type EspressoNitroTEEVerifierAWSEnclaveHashSet struct {
+	EnclaveHash [32]byte
+	Valid       bool
+	Raw         types.Log // Blockchain specific contextual infos
+}
+
+// FilterAWSEnclaveHashSet is a free log retrieval operation binding the contract event 0xb1f2a28cb3375145c700e1f69909129b208757ae95af38315661980b83a4da6a.
+//
+// Solidity: event AWSEnclaveHashSet(bytes32 enclaveHash, bool valid)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) FilterAWSEnclaveHashSet(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierAWSEnclaveHashSetIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifier.contract.FilterLogs(opts, "AWSEnclaveHashSet")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierAWSEnclaveHashSetIterator{contract: _EspressoNitroTEEVerifier.contract, event: "AWSEnclaveHashSet", logs: logs, sub: sub}, nil
+}
+
+// WatchAWSEnclaveHashSet is a free log subscription operation binding the contract event 0xb1f2a28cb3375145c700e1f69909129b208757ae95af38315661980b83a4da6a.
+//
+// Solidity: event AWSEnclaveHashSet(bytes32 enclaveHash, bool valid)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) WatchAWSEnclaveHashSet(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierAWSEnclaveHashSet) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifier.contract.WatchLogs(opts, "AWSEnclaveHashSet")
+	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(EspressoNitroTEEVerifierAWSEnclaveHashSet)
+				if err := _EspressoNitroTEEVerifier.contract.UnpackLog(event, "AWSEnclaveHashSet", 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
+}
+
+// ParseAWSEnclaveHashSet is a log parse operation binding the contract event 0xb1f2a28cb3375145c700e1f69909129b208757ae95af38315661980b83a4da6a.
+//
+// Solidity: event AWSEnclaveHashSet(bytes32 enclaveHash, bool valid)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) ParseAWSEnclaveHashSet(log types.Log) (*EspressoNitroTEEVerifierAWSEnclaveHashSet, error) {
+	event := new(EspressoNitroTEEVerifierAWSEnclaveHashSet)
+	if err := _EspressoNitroTEEVerifier.contract.UnpackLog(event, "AWSEnclaveHashSet", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierAWSSignerRegisteredIterator is returned from FilterAWSSignerRegistered and is used to iterate over the raw logs and unpacked data for AWSSignerRegistered events raised by the EspressoNitroTEEVerifier contract.
+type EspressoNitroTEEVerifierAWSSignerRegisteredIterator struct {
+	Event *EspressoNitroTEEVerifierAWSSignerRegistered // 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 *EspressoNitroTEEVerifierAWSSignerRegisteredIterator) 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(EspressoNitroTEEVerifierAWSSignerRegistered)
+			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(EspressoNitroTEEVerifierAWSSignerRegistered)
+		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 *EspressoNitroTEEVerifierAWSSignerRegisteredIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierAWSSignerRegisteredIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierAWSSignerRegistered represents a AWSSignerRegistered event raised by the EspressoNitroTEEVerifier contract.
+type EspressoNitroTEEVerifierAWSSignerRegistered struct {
+	Signer      common.Address
+	EnclaveHash [32]byte
+	Raw         types.Log // Blockchain specific contextual infos
+}
+
+// FilterAWSSignerRegistered is a free log retrieval operation binding the contract event 0x9dff6e00687e8d1229e18cae12d584610f9457243f95f608acd266087a4ed357.
+//
+// Solidity: event AWSSignerRegistered(address signer, bytes32 enclaveHash)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) FilterAWSSignerRegistered(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierAWSSignerRegisteredIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifier.contract.FilterLogs(opts, "AWSSignerRegistered")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierAWSSignerRegisteredIterator{contract: _EspressoNitroTEEVerifier.contract, event: "AWSSignerRegistered", logs: logs, sub: sub}, nil
+}
+
+// WatchAWSSignerRegistered is a free log subscription operation binding the contract event 0x9dff6e00687e8d1229e18cae12d584610f9457243f95f608acd266087a4ed357.
+//
+// Solidity: event AWSSignerRegistered(address signer, bytes32 enclaveHash)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) WatchAWSSignerRegistered(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierAWSSignerRegistered) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifier.contract.WatchLogs(opts, "AWSSignerRegistered")
+	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(EspressoNitroTEEVerifierAWSSignerRegistered)
+				if err := _EspressoNitroTEEVerifier.contract.UnpackLog(event, "AWSSignerRegistered", 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
+}
+
+// ParseAWSSignerRegistered is a log parse operation binding the contract event 0x9dff6e00687e8d1229e18cae12d584610f9457243f95f608acd266087a4ed357.
+//
+// Solidity: event AWSSignerRegistered(address signer, bytes32 enclaveHash)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) ParseAWSSignerRegistered(log types.Log) (*EspressoNitroTEEVerifierAWSSignerRegistered, error) {
+	event := new(EspressoNitroTEEVerifierAWSSignerRegistered)
+	if err := _EspressoNitroTEEVerifier.contract.UnpackLog(event, "AWSSignerRegistered", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator is returned from FilterDeletedAWSRegisteredSigner and is used to iterate over the raw logs and unpacked data for DeletedAWSRegisteredSigner events raised by the EspressoNitroTEEVerifier contract.
+type EspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator struct {
+	Event *EspressoNitroTEEVerifierDeletedAWSRegisteredSigner // 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 *EspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator) 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(EspressoNitroTEEVerifierDeletedAWSRegisteredSigner)
+			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(EspressoNitroTEEVerifierDeletedAWSRegisteredSigner)
+		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 *EspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierDeletedAWSRegisteredSigner represents a DeletedAWSRegisteredSigner event raised by the EspressoNitroTEEVerifier contract.
+type EspressoNitroTEEVerifierDeletedAWSRegisteredSigner struct {
+	Signer common.Address
+	Raw    types.Log // Blockchain specific contextual infos
+}
+
+// FilterDeletedAWSRegisteredSigner is a free log retrieval operation binding the contract event 0x6e6ee65b6e46fb8aa8f338575749d68bd7540f2244a4aa22ed24ed56cd77392c.
+//
+// Solidity: event DeletedAWSRegisteredSigner(address signer)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) FilterDeletedAWSRegisteredSigner(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifier.contract.FilterLogs(opts, "DeletedAWSRegisteredSigner")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator{contract: _EspressoNitroTEEVerifier.contract, event: "DeletedAWSRegisteredSigner", logs: logs, sub: sub}, nil
+}
+
+// WatchDeletedAWSRegisteredSigner is a free log subscription operation binding the contract event 0x6e6ee65b6e46fb8aa8f338575749d68bd7540f2244a4aa22ed24ed56cd77392c.
+//
+// Solidity: event DeletedAWSRegisteredSigner(address signer)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) WatchDeletedAWSRegisteredSigner(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierDeletedAWSRegisteredSigner) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifier.contract.WatchLogs(opts, "DeletedAWSRegisteredSigner")
+	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(EspressoNitroTEEVerifierDeletedAWSRegisteredSigner)
+				if err := _EspressoNitroTEEVerifier.contract.UnpackLog(event, "DeletedAWSRegisteredSigner", 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
+}
+
+// ParseDeletedAWSRegisteredSigner is a log parse operation binding the contract event 0x6e6ee65b6e46fb8aa8f338575749d68bd7540f2244a4aa22ed24ed56cd77392c.
+//
+// Solidity: event DeletedAWSRegisteredSigner(address signer)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) ParseDeletedAWSRegisteredSigner(log types.Log) (*EspressoNitroTEEVerifierDeletedAWSRegisteredSigner, error) {
+	event := new(EspressoNitroTEEVerifierDeletedAWSRegisteredSigner)
+	if err := _EspressoNitroTEEVerifier.contract.UnpackLog(event, "DeletedAWSRegisteredSigner", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierOwnershipTransferStartedIterator is returned from FilterOwnershipTransferStarted and is used to iterate over the raw logs and unpacked data for OwnershipTransferStarted events raised by the EspressoNitroTEEVerifier contract.
+type EspressoNitroTEEVerifierOwnershipTransferStartedIterator struct {
+	Event *EspressoNitroTEEVerifierOwnershipTransferStarted // 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 *EspressoNitroTEEVerifierOwnershipTransferStartedIterator) 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(EspressoNitroTEEVerifierOwnershipTransferStarted)
+			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(EspressoNitroTEEVerifierOwnershipTransferStarted)
+		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 *EspressoNitroTEEVerifierOwnershipTransferStartedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierOwnershipTransferStartedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierOwnershipTransferStarted represents a OwnershipTransferStarted event raised by the EspressoNitroTEEVerifier contract.
+type EspressoNitroTEEVerifierOwnershipTransferStarted struct {
+	PreviousOwner common.Address
+	NewOwner      common.Address
+	Raw           types.Log // Blockchain specific contextual infos
+}
+
+// FilterOwnershipTransferStarted is a free log retrieval operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) FilterOwnershipTransferStarted(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*EspressoNitroTEEVerifierOwnershipTransferStartedIterator, 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 := _EspressoNitroTEEVerifier.contract.FilterLogs(opts, "OwnershipTransferStarted", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierOwnershipTransferStartedIterator{contract: _EspressoNitroTEEVerifier.contract, event: "OwnershipTransferStarted", logs: logs, sub: sub}, nil
+}
+
+// WatchOwnershipTransferStarted is a free log subscription operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) WatchOwnershipTransferStarted(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierOwnershipTransferStarted, 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 := _EspressoNitroTEEVerifier.contract.WatchLogs(opts, "OwnershipTransferStarted", 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(EspressoNitroTEEVerifierOwnershipTransferStarted)
+				if err := _EspressoNitroTEEVerifier.contract.UnpackLog(event, "OwnershipTransferStarted", 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
+}
+
+// ParseOwnershipTransferStarted is a log parse operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) ParseOwnershipTransferStarted(log types.Log) (*EspressoNitroTEEVerifierOwnershipTransferStarted, error) {
+	event := new(EspressoNitroTEEVerifierOwnershipTransferStarted)
+	if err := _EspressoNitroTEEVerifier.contract.UnpackLog(event, "OwnershipTransferStarted", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the EspressoNitroTEEVerifier contract.
+type EspressoNitroTEEVerifierOwnershipTransferredIterator struct {
+	Event *EspressoNitroTEEVerifierOwnershipTransferred // 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 *EspressoNitroTEEVerifierOwnershipTransferredIterator) 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(EspressoNitroTEEVerifierOwnershipTransferred)
+			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(EspressoNitroTEEVerifierOwnershipTransferred)
+		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 *EspressoNitroTEEVerifierOwnershipTransferredIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierOwnershipTransferredIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierOwnershipTransferred represents a OwnershipTransferred event raised by the EspressoNitroTEEVerifier contract.
+type EspressoNitroTEEVerifierOwnershipTransferred 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 (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*EspressoNitroTEEVerifierOwnershipTransferredIterator, 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 := _EspressoNitroTEEVerifier.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierOwnershipTransferredIterator{contract: _EspressoNitroTEEVerifier.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 (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierOwnershipTransferred, 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 := _EspressoNitroTEEVerifier.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(EspressoNitroTEEVerifierOwnershipTransferred)
+				if err := _EspressoNitroTEEVerifier.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 (_EspressoNitroTEEVerifier *EspressoNitroTEEVerifierFilterer) ParseOwnershipTransferred(log types.Log) (*EspressoNitroTEEVerifierOwnershipTransferred, error) {
+	event := new(EspressoNitroTEEVerifierOwnershipTransferred)
+	if err := _EspressoNitroTEEVerifier.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestMetaData contains all meta data concerning the EspressoNitroTEEVerifierTest contract.
+var EspressoNitroTEEVerifierTestMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testDeleteRegisterSignerOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testInvalidAttestionPrefix\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testInvalidSignature\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testNitroOwnershipTransfer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testNitroOwnershipTransferFailure\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testOldAttestation\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testRegisterSigner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testRegisterSignerInvalidPCR0Hash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testRegisterSignerWithIndefiniteItemLengthAttestation\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testSetNitroEnclaveHash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testVerifyCert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testVerifyCertChain\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testVerifyCertParentCertNotVerified\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"}]",
+	Bin: "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",
+}
+
+// EspressoNitroTEEVerifierTestABI is the input ABI used to generate the binding from.
+// Deprecated: Use EspressoNitroTEEVerifierTestMetaData.ABI instead.
+var EspressoNitroTEEVerifierTestABI = EspressoNitroTEEVerifierTestMetaData.ABI
+
+// EspressoNitroTEEVerifierTestBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use EspressoNitroTEEVerifierTestMetaData.Bin instead.
+var EspressoNitroTEEVerifierTestBin = EspressoNitroTEEVerifierTestMetaData.Bin
+
+// DeployEspressoNitroTEEVerifierTest deploys a new Ethereum contract, binding an instance of EspressoNitroTEEVerifierTest to it.
+func DeployEspressoNitroTEEVerifierTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *EspressoNitroTEEVerifierTest, error) {
+	parsed, err := EspressoNitroTEEVerifierTestMetaData.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(EspressoNitroTEEVerifierTestBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &EspressoNitroTEEVerifierTest{EspressoNitroTEEVerifierTestCaller: EspressoNitroTEEVerifierTestCaller{contract: contract}, EspressoNitroTEEVerifierTestTransactor: EspressoNitroTEEVerifierTestTransactor{contract: contract}, EspressoNitroTEEVerifierTestFilterer: EspressoNitroTEEVerifierTestFilterer{contract: contract}}, nil
+}
+
+// EspressoNitroTEEVerifierTest is an auto generated Go binding around an Ethereum contract.
+type EspressoNitroTEEVerifierTest struct {
+	EspressoNitroTEEVerifierTestCaller     // Read-only binding to the contract
+	EspressoNitroTEEVerifierTestTransactor // Write-only binding to the contract
+	EspressoNitroTEEVerifierTestFilterer   // Log filterer for contract events
+}
+
+// EspressoNitroTEEVerifierTestCaller is an auto generated read-only Go binding around an Ethereum contract.
+type EspressoNitroTEEVerifierTestCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoNitroTEEVerifierTestTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type EspressoNitroTEEVerifierTestTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoNitroTEEVerifierTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type EspressoNitroTEEVerifierTestFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoNitroTEEVerifierTestSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type EspressoNitroTEEVerifierTestSession struct {
+	Contract     *EspressoNitroTEEVerifierTest // 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
+}
+
+// EspressoNitroTEEVerifierTestCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type EspressoNitroTEEVerifierTestCallerSession struct {
+	Contract *EspressoNitroTEEVerifierTestCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts                       // Call options to use throughout this session
+}
+
+// EspressoNitroTEEVerifierTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type EspressoNitroTEEVerifierTestTransactorSession struct {
+	Contract     *EspressoNitroTEEVerifierTestTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts                       // Transaction auth options to use throughout this session
+}
+
+// EspressoNitroTEEVerifierTestRaw is an auto generated low-level Go binding around an Ethereum contract.
+type EspressoNitroTEEVerifierTestRaw struct {
+	Contract *EspressoNitroTEEVerifierTest // Generic contract binding to access the raw methods on
+}
+
+// EspressoNitroTEEVerifierTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type EspressoNitroTEEVerifierTestCallerRaw struct {
+	Contract *EspressoNitroTEEVerifierTestCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// EspressoNitroTEEVerifierTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type EspressoNitroTEEVerifierTestTransactorRaw struct {
+	Contract *EspressoNitroTEEVerifierTestTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewEspressoNitroTEEVerifierTest creates a new instance of EspressoNitroTEEVerifierTest, bound to a specific deployed contract.
+func NewEspressoNitroTEEVerifierTest(address common.Address, backend bind.ContractBackend) (*EspressoNitroTEEVerifierTest, error) {
+	contract, err := bindEspressoNitroTEEVerifierTest(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTest{EspressoNitroTEEVerifierTestCaller: EspressoNitroTEEVerifierTestCaller{contract: contract}, EspressoNitroTEEVerifierTestTransactor: EspressoNitroTEEVerifierTestTransactor{contract: contract}, EspressoNitroTEEVerifierTestFilterer: EspressoNitroTEEVerifierTestFilterer{contract: contract}}, nil
+}
+
+// NewEspressoNitroTEEVerifierTestCaller creates a new read-only instance of EspressoNitroTEEVerifierTest, bound to a specific deployed contract.
+func NewEspressoNitroTEEVerifierTestCaller(address common.Address, caller bind.ContractCaller) (*EspressoNitroTEEVerifierTestCaller, error) {
+	contract, err := bindEspressoNitroTEEVerifierTest(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestCaller{contract: contract}, nil
+}
+
+// NewEspressoNitroTEEVerifierTestTransactor creates a new write-only instance of EspressoNitroTEEVerifierTest, bound to a specific deployed contract.
+func NewEspressoNitroTEEVerifierTestTransactor(address common.Address, transactor bind.ContractTransactor) (*EspressoNitroTEEVerifierTestTransactor, error) {
+	contract, err := bindEspressoNitroTEEVerifierTest(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestTransactor{contract: contract}, nil
+}
+
+// NewEspressoNitroTEEVerifierTestFilterer creates a new log filterer instance of EspressoNitroTEEVerifierTest, bound to a specific deployed contract.
+func NewEspressoNitroTEEVerifierTestFilterer(address common.Address, filterer bind.ContractFilterer) (*EspressoNitroTEEVerifierTestFilterer, error) {
+	contract, err := bindEspressoNitroTEEVerifierTest(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestFilterer{contract: contract}, nil
+}
+
+// bindEspressoNitroTEEVerifierTest binds a generic wrapper to an already deployed contract.
+func bindEspressoNitroTEEVerifierTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := EspressoNitroTEEVerifierTestMetaData.GetAbi()
+	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 (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoNitroTEEVerifierTest.Contract.EspressoNitroTEEVerifierTestCaller.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 (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.EspressoNitroTEEVerifierTestTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.EspressoNitroTEEVerifierTestTransactor.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 (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoNitroTEEVerifierTest.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 (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.contract.Transact(opts, method, params...)
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCaller) ISTEST(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifierTest.contract.Call(opts, &out, "IS_TEST")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) ISTEST() (bool, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.ISTEST(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCallerSession) ISTEST() (bool, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.ISTEST(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCaller) ExcludeArtifacts(opts *bind.CallOpts) ([]string, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifierTest.contract.Call(opts, &out, "excludeArtifacts")
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) ExcludeArtifacts() ([]string, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.ExcludeArtifacts(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCallerSession) ExcludeArtifacts() ([]string, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.ExcludeArtifacts(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCaller) ExcludeContracts(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifierTest.contract.Call(opts, &out, "excludeContracts")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) ExcludeContracts() ([]common.Address, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.ExcludeContracts(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCallerSession) ExcludeContracts() ([]common.Address, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.ExcludeContracts(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCaller) ExcludeSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifierTest.contract.Call(opts, &out, "excludeSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector)
+
+	return out0, err
+
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.ExcludeSelectors(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCallerSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.ExcludeSelectors(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCaller) ExcludeSenders(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifierTest.contract.Call(opts, &out, "excludeSenders")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) ExcludeSenders() ([]common.Address, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.ExcludeSenders(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCallerSession) ExcludeSenders() ([]common.Address, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.ExcludeSenders(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCaller) Failed(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifierTest.contract.Call(opts, &out, "failed")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) Failed() (bool, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.Failed(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCallerSession) Failed() (bool, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.Failed(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCaller) TargetArtifactSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzArtifactSelector, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifierTest.contract.Call(opts, &out, "targetArtifactSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzArtifactSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzArtifactSelector)).(*[]StdInvariantFuzzArtifactSelector)
+
+	return out0, err
+
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TargetArtifactSelectors(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCallerSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TargetArtifactSelectors(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCaller) TargetArtifacts(opts *bind.CallOpts) ([]string, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifierTest.contract.Call(opts, &out, "targetArtifacts")
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TargetArtifacts() ([]string, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TargetArtifacts(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCallerSession) TargetArtifacts() ([]string, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TargetArtifacts(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCaller) TargetContracts(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifierTest.contract.Call(opts, &out, "targetContracts")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TargetContracts() ([]common.Address, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TargetContracts(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCallerSession) TargetContracts() ([]common.Address, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TargetContracts(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCaller) TargetInterfaces(opts *bind.CallOpts) ([]StdInvariantFuzzInterface, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifierTest.contract.Call(opts, &out, "targetInterfaces")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzInterface), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzInterface)).(*[]StdInvariantFuzzInterface)
+
+	return out0, err
+
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TargetInterfaces(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCallerSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TargetInterfaces(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCaller) TargetSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifierTest.contract.Call(opts, &out, "targetSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector)
+
+	return out0, err
+
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TargetSelectors(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCallerSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TargetSelectors(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCaller) TargetSenders(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoNitroTEEVerifierTest.contract.Call(opts, &out, "targetSenders")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TargetSenders() ([]common.Address, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TargetSenders(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestCallerSession) TargetSenders() ([]common.Address, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TargetSenders(&_EspressoNitroTEEVerifierTest.CallOpts)
+}
+
+// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4.
+//
+// Solidity: function setUp() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) SetUp(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "setUp")
+}
+
+// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4.
+//
+// Solidity: function setUp() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) SetUp() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.SetUp(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4.
+//
+// Solidity: function setUp() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) SetUp() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.SetUp(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestDeleteRegisterSignerOwnership is a paid mutator transaction binding the contract method 0xf57beef1.
+//
+// Solidity: function testDeleteRegisterSignerOwnership() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) TestDeleteRegisterSignerOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "testDeleteRegisterSignerOwnership")
+}
+
+// TestDeleteRegisterSignerOwnership is a paid mutator transaction binding the contract method 0xf57beef1.
+//
+// Solidity: function testDeleteRegisterSignerOwnership() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TestDeleteRegisterSignerOwnership() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestDeleteRegisterSignerOwnership(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestDeleteRegisterSignerOwnership is a paid mutator transaction binding the contract method 0xf57beef1.
+//
+// Solidity: function testDeleteRegisterSignerOwnership() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) TestDeleteRegisterSignerOwnership() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestDeleteRegisterSignerOwnership(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestInvalidAttestionPrefix is a paid mutator transaction binding the contract method 0xa2125bff.
+//
+// Solidity: function testInvalidAttestionPrefix() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) TestInvalidAttestionPrefix(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "testInvalidAttestionPrefix")
+}
+
+// TestInvalidAttestionPrefix is a paid mutator transaction binding the contract method 0xa2125bff.
+//
+// Solidity: function testInvalidAttestionPrefix() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TestInvalidAttestionPrefix() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestInvalidAttestionPrefix(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestInvalidAttestionPrefix is a paid mutator transaction binding the contract method 0xa2125bff.
+//
+// Solidity: function testInvalidAttestionPrefix() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) TestInvalidAttestionPrefix() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestInvalidAttestionPrefix(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestInvalidSignature is a paid mutator transaction binding the contract method 0xf9d90c8d.
+//
+// Solidity: function testInvalidSignature() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) TestInvalidSignature(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "testInvalidSignature")
+}
+
+// TestInvalidSignature is a paid mutator transaction binding the contract method 0xf9d90c8d.
+//
+// Solidity: function testInvalidSignature() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TestInvalidSignature() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestInvalidSignature(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestInvalidSignature is a paid mutator transaction binding the contract method 0xf9d90c8d.
+//
+// Solidity: function testInvalidSignature() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) TestInvalidSignature() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestInvalidSignature(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestNitroOwnershipTransfer is a paid mutator transaction binding the contract method 0x3d482e14.
+//
+// Solidity: function testNitroOwnershipTransfer() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) TestNitroOwnershipTransfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "testNitroOwnershipTransfer")
+}
+
+// TestNitroOwnershipTransfer is a paid mutator transaction binding the contract method 0x3d482e14.
+//
+// Solidity: function testNitroOwnershipTransfer() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TestNitroOwnershipTransfer() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestNitroOwnershipTransfer(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestNitroOwnershipTransfer is a paid mutator transaction binding the contract method 0x3d482e14.
+//
+// Solidity: function testNitroOwnershipTransfer() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) TestNitroOwnershipTransfer() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestNitroOwnershipTransfer(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestNitroOwnershipTransferFailure is a paid mutator transaction binding the contract method 0x324a0e26.
+//
+// Solidity: function testNitroOwnershipTransferFailure() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) TestNitroOwnershipTransferFailure(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "testNitroOwnershipTransferFailure")
+}
+
+// TestNitroOwnershipTransferFailure is a paid mutator transaction binding the contract method 0x324a0e26.
+//
+// Solidity: function testNitroOwnershipTransferFailure() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TestNitroOwnershipTransferFailure() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestNitroOwnershipTransferFailure(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestNitroOwnershipTransferFailure is a paid mutator transaction binding the contract method 0x324a0e26.
+//
+// Solidity: function testNitroOwnershipTransferFailure() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) TestNitroOwnershipTransferFailure() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestNitroOwnershipTransferFailure(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestOldAttestation is a paid mutator transaction binding the contract method 0xf241a4b3.
+//
+// Solidity: function testOldAttestation() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) TestOldAttestation(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "testOldAttestation")
+}
+
+// TestOldAttestation is a paid mutator transaction binding the contract method 0xf241a4b3.
+//
+// Solidity: function testOldAttestation() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TestOldAttestation() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestOldAttestation(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestOldAttestation is a paid mutator transaction binding the contract method 0xf241a4b3.
+//
+// Solidity: function testOldAttestation() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) TestOldAttestation() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestOldAttestation(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSigner is a paid mutator transaction binding the contract method 0xfa94f83d.
+//
+// Solidity: function testRegisterSigner() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) TestRegisterSigner(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "testRegisterSigner")
+}
+
+// TestRegisterSigner is a paid mutator transaction binding the contract method 0xfa94f83d.
+//
+// Solidity: function testRegisterSigner() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TestRegisterSigner() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestRegisterSigner(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSigner is a paid mutator transaction binding the contract method 0xfa94f83d.
+//
+// Solidity: function testRegisterSigner() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) TestRegisterSigner() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestRegisterSigner(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSignerInvalidPCR0Hash is a paid mutator transaction binding the contract method 0xaede393c.
+//
+// Solidity: function testRegisterSignerInvalidPCR0Hash() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) TestRegisterSignerInvalidPCR0Hash(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "testRegisterSignerInvalidPCR0Hash")
+}
+
+// TestRegisterSignerInvalidPCR0Hash is a paid mutator transaction binding the contract method 0xaede393c.
+//
+// Solidity: function testRegisterSignerInvalidPCR0Hash() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TestRegisterSignerInvalidPCR0Hash() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestRegisterSignerInvalidPCR0Hash(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSignerInvalidPCR0Hash is a paid mutator transaction binding the contract method 0xaede393c.
+//
+// Solidity: function testRegisterSignerInvalidPCR0Hash() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) TestRegisterSignerInvalidPCR0Hash() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestRegisterSignerInvalidPCR0Hash(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSignerWithIndefiniteItemLengthAttestation is a paid mutator transaction binding the contract method 0x9faaeeaf.
+//
+// Solidity: function testRegisterSignerWithIndefiniteItemLengthAttestation() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) TestRegisterSignerWithIndefiniteItemLengthAttestation(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "testRegisterSignerWithIndefiniteItemLengthAttestation")
+}
+
+// TestRegisterSignerWithIndefiniteItemLengthAttestation is a paid mutator transaction binding the contract method 0x9faaeeaf.
+//
+// Solidity: function testRegisterSignerWithIndefiniteItemLengthAttestation() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TestRegisterSignerWithIndefiniteItemLengthAttestation() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestRegisterSignerWithIndefiniteItemLengthAttestation(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSignerWithIndefiniteItemLengthAttestation is a paid mutator transaction binding the contract method 0x9faaeeaf.
+//
+// Solidity: function testRegisterSignerWithIndefiniteItemLengthAttestation() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) TestRegisterSignerWithIndefiniteItemLengthAttestation() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestRegisterSignerWithIndefiniteItemLengthAttestation(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestSetNitroEnclaveHash is a paid mutator transaction binding the contract method 0xeab498f4.
+//
+// Solidity: function testSetNitroEnclaveHash() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) TestSetNitroEnclaveHash(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "testSetNitroEnclaveHash")
+}
+
+// TestSetNitroEnclaveHash is a paid mutator transaction binding the contract method 0xeab498f4.
+//
+// Solidity: function testSetNitroEnclaveHash() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TestSetNitroEnclaveHash() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestSetNitroEnclaveHash(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestSetNitroEnclaveHash is a paid mutator transaction binding the contract method 0xeab498f4.
+//
+// Solidity: function testSetNitroEnclaveHash() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) TestSetNitroEnclaveHash() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestSetNitroEnclaveHash(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyCert is a paid mutator transaction binding the contract method 0x607a1706.
+//
+// Solidity: function testVerifyCert() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) TestVerifyCert(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "testVerifyCert")
+}
+
+// TestVerifyCert is a paid mutator transaction binding the contract method 0x607a1706.
+//
+// Solidity: function testVerifyCert() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TestVerifyCert() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestVerifyCert(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyCert is a paid mutator transaction binding the contract method 0x607a1706.
+//
+// Solidity: function testVerifyCert() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) TestVerifyCert() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestVerifyCert(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyCertChain is a paid mutator transaction binding the contract method 0x79744088.
+//
+// Solidity: function testVerifyCertChain() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) TestVerifyCertChain(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "testVerifyCertChain")
+}
+
+// TestVerifyCertChain is a paid mutator transaction binding the contract method 0x79744088.
+//
+// Solidity: function testVerifyCertChain() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TestVerifyCertChain() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestVerifyCertChain(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyCertChain is a paid mutator transaction binding the contract method 0x79744088.
+//
+// Solidity: function testVerifyCertChain() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) TestVerifyCertChain() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestVerifyCertChain(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyCertParentCertNotVerified is a paid mutator transaction binding the contract method 0x9afd78de.
+//
+// Solidity: function testVerifyCertParentCertNotVerified() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactor) TestVerifyCertParentCertNotVerified(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.contract.Transact(opts, "testVerifyCertParentCertNotVerified")
+}
+
+// TestVerifyCertParentCertNotVerified is a paid mutator transaction binding the contract method 0x9afd78de.
+//
+// Solidity: function testVerifyCertParentCertNotVerified() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestSession) TestVerifyCertParentCertNotVerified() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestVerifyCertParentCertNotVerified(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyCertParentCertNotVerified is a paid mutator transaction binding the contract method 0x9afd78de.
+//
+// Solidity: function testVerifyCertParentCertNotVerified() returns()
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestTransactorSession) TestVerifyCertParentCertNotVerified() (*types.Transaction, error) {
+	return _EspressoNitroTEEVerifierTest.Contract.TestVerifyCertParentCertNotVerified(&_EspressoNitroTEEVerifierTest.TransactOpts)
+}
+
+// EspressoNitroTEEVerifierTestLogIterator is returned from FilterLog and is used to iterate over the raw logs and unpacked data for Log events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogIterator struct {
+	Event *EspressoNitroTEEVerifierTestLog // 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 *EspressoNitroTEEVerifierTestLogIterator) 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(EspressoNitroTEEVerifierTestLog)
+			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(EspressoNitroTEEVerifierTestLog)
+		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 *EspressoNitroTEEVerifierTestLogIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLog represents a Log event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLog struct {
+	Arg0 string
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLog is a free log retrieval operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLog(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log", logs: logs, sub: sub}, nil
+}
+
+// WatchLog is a free log subscription operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLog(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLog) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log")
+	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(EspressoNitroTEEVerifierTestLog)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log", 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
+}
+
+// ParseLog is a log parse operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLog(log types.Log) (*EspressoNitroTEEVerifierTestLog, error) {
+	event := new(EspressoNitroTEEVerifierTestLog)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogAddressIterator is returned from FilterLogAddress and is used to iterate over the raw logs and unpacked data for LogAddress events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogAddressIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogAddress // 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 *EspressoNitroTEEVerifierTestLogAddressIterator) 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(EspressoNitroTEEVerifierTestLogAddress)
+			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(EspressoNitroTEEVerifierTestLogAddress)
+		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 *EspressoNitroTEEVerifierTestLogAddressIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogAddressIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogAddress represents a LogAddress event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogAddress struct {
+	Arg0 common.Address
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogAddress is a free log retrieval operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogAddress(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogAddressIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_address")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogAddressIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_address", logs: logs, sub: sub}, nil
+}
+
+// WatchLogAddress is a free log subscription operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogAddress(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogAddress) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_address")
+	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(EspressoNitroTEEVerifierTestLogAddress)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_address", 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
+}
+
+// ParseLogAddress is a log parse operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogAddress(log types.Log) (*EspressoNitroTEEVerifierTestLogAddress, error) {
+	event := new(EspressoNitroTEEVerifierTestLogAddress)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_address", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogArrayIterator is returned from FilterLogArray and is used to iterate over the raw logs and unpacked data for LogArray events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogArrayIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogArray // 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 *EspressoNitroTEEVerifierTestLogArrayIterator) 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(EspressoNitroTEEVerifierTestLogArray)
+			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(EspressoNitroTEEVerifierTestLogArray)
+		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 *EspressoNitroTEEVerifierTestLogArrayIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogArrayIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogArray represents a LogArray event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogArray struct {
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray is a free log retrieval operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogArray(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogArrayIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_array")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogArrayIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_array", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray is a free log subscription operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogArray(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogArray) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_array")
+	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(EspressoNitroTEEVerifierTestLogArray)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_array", 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
+}
+
+// ParseLogArray is a log parse operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogArray(log types.Log) (*EspressoNitroTEEVerifierTestLogArray, error) {
+	event := new(EspressoNitroTEEVerifierTestLogArray)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_array", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogArray0Iterator is returned from FilterLogArray0 and is used to iterate over the raw logs and unpacked data for LogArray0 events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogArray0Iterator struct {
+	Event *EspressoNitroTEEVerifierTestLogArray0 // 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 *EspressoNitroTEEVerifierTestLogArray0Iterator) 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(EspressoNitroTEEVerifierTestLogArray0)
+			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(EspressoNitroTEEVerifierTestLogArray0)
+		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 *EspressoNitroTEEVerifierTestLogArray0Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogArray0Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogArray0 represents a LogArray0 event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogArray0 struct {
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray0 is a free log retrieval operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogArray0(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogArray0Iterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_array0")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogArray0Iterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_array0", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray0 is a free log subscription operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogArray0(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogArray0) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_array0")
+	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(EspressoNitroTEEVerifierTestLogArray0)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_array0", 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
+}
+
+// ParseLogArray0 is a log parse operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogArray0(log types.Log) (*EspressoNitroTEEVerifierTestLogArray0, error) {
+	event := new(EspressoNitroTEEVerifierTestLogArray0)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_array0", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogArray1Iterator is returned from FilterLogArray1 and is used to iterate over the raw logs and unpacked data for LogArray1 events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogArray1Iterator struct {
+	Event *EspressoNitroTEEVerifierTestLogArray1 // 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 *EspressoNitroTEEVerifierTestLogArray1Iterator) 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(EspressoNitroTEEVerifierTestLogArray1)
+			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(EspressoNitroTEEVerifierTestLogArray1)
+		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 *EspressoNitroTEEVerifierTestLogArray1Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogArray1Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogArray1 represents a LogArray1 event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogArray1 struct {
+	Val []common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray1 is a free log retrieval operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogArray1(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogArray1Iterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_array1")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogArray1Iterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_array1", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray1 is a free log subscription operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogArray1(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogArray1) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_array1")
+	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(EspressoNitroTEEVerifierTestLogArray1)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_array1", 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
+}
+
+// ParseLogArray1 is a log parse operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogArray1(log types.Log) (*EspressoNitroTEEVerifierTestLogArray1, error) {
+	event := new(EspressoNitroTEEVerifierTestLogArray1)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_array1", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogBytesIterator is returned from FilterLogBytes and is used to iterate over the raw logs and unpacked data for LogBytes events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogBytesIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogBytes // 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 *EspressoNitroTEEVerifierTestLogBytesIterator) 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(EspressoNitroTEEVerifierTestLogBytes)
+			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(EspressoNitroTEEVerifierTestLogBytes)
+		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 *EspressoNitroTEEVerifierTestLogBytesIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogBytesIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogBytes represents a LogBytes event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogBytes struct {
+	Arg0 []byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogBytes is a free log retrieval operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogBytes(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogBytesIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_bytes")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogBytesIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_bytes", logs: logs, sub: sub}, nil
+}
+
+// WatchLogBytes is a free log subscription operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogBytes(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogBytes) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_bytes")
+	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(EspressoNitroTEEVerifierTestLogBytes)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_bytes", 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
+}
+
+// ParseLogBytes is a log parse operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogBytes(log types.Log) (*EspressoNitroTEEVerifierTestLogBytes, error) {
+	event := new(EspressoNitroTEEVerifierTestLogBytes)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_bytes", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogBytes32Iterator is returned from FilterLogBytes32 and is used to iterate over the raw logs and unpacked data for LogBytes32 events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogBytes32Iterator struct {
+	Event *EspressoNitroTEEVerifierTestLogBytes32 // 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 *EspressoNitroTEEVerifierTestLogBytes32Iterator) 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(EspressoNitroTEEVerifierTestLogBytes32)
+			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(EspressoNitroTEEVerifierTestLogBytes32)
+		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 *EspressoNitroTEEVerifierTestLogBytes32Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogBytes32Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogBytes32 represents a LogBytes32 event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogBytes32 struct {
+	Arg0 [32]byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogBytes32 is a free log retrieval operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogBytes32(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogBytes32Iterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_bytes32")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogBytes32Iterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_bytes32", logs: logs, sub: sub}, nil
+}
+
+// WatchLogBytes32 is a free log subscription operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogBytes32(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogBytes32) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_bytes32")
+	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(EspressoNitroTEEVerifierTestLogBytes32)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_bytes32", 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
+}
+
+// ParseLogBytes32 is a log parse operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogBytes32(log types.Log) (*EspressoNitroTEEVerifierTestLogBytes32, error) {
+	event := new(EspressoNitroTEEVerifierTestLogBytes32)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_bytes32", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogIntIterator is returned from FilterLogInt and is used to iterate over the raw logs and unpacked data for LogInt events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogIntIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogInt // 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 *EspressoNitroTEEVerifierTestLogIntIterator) 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(EspressoNitroTEEVerifierTestLogInt)
+			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(EspressoNitroTEEVerifierTestLogInt)
+		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 *EspressoNitroTEEVerifierTestLogIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogInt represents a LogInt event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogInt struct {
+	Arg0 *big.Int
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogInt is a free log retrieval operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogInt(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogIntIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_int")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogIntIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogInt is a free log subscription operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogInt(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogInt) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_int")
+	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(EspressoNitroTEEVerifierTestLogInt)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_int", 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
+}
+
+// ParseLogInt is a log parse operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogInt(log types.Log) (*EspressoNitroTEEVerifierTestLogInt, error) {
+	event := new(EspressoNitroTEEVerifierTestLogInt)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedAddressIterator is returned from FilterLogNamedAddress and is used to iterate over the raw logs and unpacked data for LogNamedAddress events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedAddressIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogNamedAddress // 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 *EspressoNitroTEEVerifierTestLogNamedAddressIterator) 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(EspressoNitroTEEVerifierTestLogNamedAddress)
+			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(EspressoNitroTEEVerifierTestLogNamedAddress)
+		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 *EspressoNitroTEEVerifierTestLogNamedAddressIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogNamedAddressIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedAddress represents a LogNamedAddress event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedAddress struct {
+	Key string
+	Val common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedAddress is a free log retrieval operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogNamedAddress(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogNamedAddressIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_named_address")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogNamedAddressIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_named_address", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedAddress is a free log subscription operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogNamedAddress(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogNamedAddress) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_named_address")
+	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(EspressoNitroTEEVerifierTestLogNamedAddress)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_address", 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
+}
+
+// ParseLogNamedAddress is a log parse operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogNamedAddress(log types.Log) (*EspressoNitroTEEVerifierTestLogNamedAddress, error) {
+	event := new(EspressoNitroTEEVerifierTestLogNamedAddress)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_address", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedArrayIterator is returned from FilterLogNamedArray and is used to iterate over the raw logs and unpacked data for LogNamedArray events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedArrayIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogNamedArray // 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 *EspressoNitroTEEVerifierTestLogNamedArrayIterator) 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(EspressoNitroTEEVerifierTestLogNamedArray)
+			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(EspressoNitroTEEVerifierTestLogNamedArray)
+		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 *EspressoNitroTEEVerifierTestLogNamedArrayIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogNamedArrayIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedArray represents a LogNamedArray event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedArray struct {
+	Key string
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray is a free log retrieval operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogNamedArray(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogNamedArrayIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_named_array")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogNamedArrayIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_named_array", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray is a free log subscription operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogNamedArray(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogNamedArray) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_named_array")
+	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(EspressoNitroTEEVerifierTestLogNamedArray)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_array", 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
+}
+
+// ParseLogNamedArray is a log parse operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogNamedArray(log types.Log) (*EspressoNitroTEEVerifierTestLogNamedArray, error) {
+	event := new(EspressoNitroTEEVerifierTestLogNamedArray)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_array", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedArray0Iterator is returned from FilterLogNamedArray0 and is used to iterate over the raw logs and unpacked data for LogNamedArray0 events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedArray0Iterator struct {
+	Event *EspressoNitroTEEVerifierTestLogNamedArray0 // 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 *EspressoNitroTEEVerifierTestLogNamedArray0Iterator) 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(EspressoNitroTEEVerifierTestLogNamedArray0)
+			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(EspressoNitroTEEVerifierTestLogNamedArray0)
+		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 *EspressoNitroTEEVerifierTestLogNamedArray0Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogNamedArray0Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedArray0 represents a LogNamedArray0 event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedArray0 struct {
+	Key string
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray0 is a free log retrieval operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogNamedArray0(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogNamedArray0Iterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_named_array0")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogNamedArray0Iterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_named_array0", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray0 is a free log subscription operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogNamedArray0(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogNamedArray0) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_named_array0")
+	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(EspressoNitroTEEVerifierTestLogNamedArray0)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_array0", 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
+}
+
+// ParseLogNamedArray0 is a log parse operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogNamedArray0(log types.Log) (*EspressoNitroTEEVerifierTestLogNamedArray0, error) {
+	event := new(EspressoNitroTEEVerifierTestLogNamedArray0)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_array0", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedArray1Iterator is returned from FilterLogNamedArray1 and is used to iterate over the raw logs and unpacked data for LogNamedArray1 events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedArray1Iterator struct {
+	Event *EspressoNitroTEEVerifierTestLogNamedArray1 // 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 *EspressoNitroTEEVerifierTestLogNamedArray1Iterator) 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(EspressoNitroTEEVerifierTestLogNamedArray1)
+			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(EspressoNitroTEEVerifierTestLogNamedArray1)
+		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 *EspressoNitroTEEVerifierTestLogNamedArray1Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogNamedArray1Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedArray1 represents a LogNamedArray1 event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedArray1 struct {
+	Key string
+	Val []common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray1 is a free log retrieval operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogNamedArray1(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogNamedArray1Iterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_named_array1")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogNamedArray1Iterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_named_array1", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray1 is a free log subscription operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogNamedArray1(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogNamedArray1) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_named_array1")
+	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(EspressoNitroTEEVerifierTestLogNamedArray1)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_array1", 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
+}
+
+// ParseLogNamedArray1 is a log parse operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogNamedArray1(log types.Log) (*EspressoNitroTEEVerifierTestLogNamedArray1, error) {
+	event := new(EspressoNitroTEEVerifierTestLogNamedArray1)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_array1", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedBytesIterator is returned from FilterLogNamedBytes and is used to iterate over the raw logs and unpacked data for LogNamedBytes events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedBytesIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogNamedBytes // 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 *EspressoNitroTEEVerifierTestLogNamedBytesIterator) 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(EspressoNitroTEEVerifierTestLogNamedBytes)
+			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(EspressoNitroTEEVerifierTestLogNamedBytes)
+		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 *EspressoNitroTEEVerifierTestLogNamedBytesIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogNamedBytesIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedBytes represents a LogNamedBytes event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedBytes struct {
+	Key string
+	Val []byte
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedBytes is a free log retrieval operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogNamedBytes(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogNamedBytesIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_named_bytes")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogNamedBytesIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_named_bytes", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedBytes is a free log subscription operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogNamedBytes(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogNamedBytes) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_named_bytes")
+	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(EspressoNitroTEEVerifierTestLogNamedBytes)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_bytes", 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
+}
+
+// ParseLogNamedBytes is a log parse operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogNamedBytes(log types.Log) (*EspressoNitroTEEVerifierTestLogNamedBytes, error) {
+	event := new(EspressoNitroTEEVerifierTestLogNamedBytes)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_bytes", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedBytes32Iterator is returned from FilterLogNamedBytes32 and is used to iterate over the raw logs and unpacked data for LogNamedBytes32 events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedBytes32Iterator struct {
+	Event *EspressoNitroTEEVerifierTestLogNamedBytes32 // 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 *EspressoNitroTEEVerifierTestLogNamedBytes32Iterator) 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(EspressoNitroTEEVerifierTestLogNamedBytes32)
+			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(EspressoNitroTEEVerifierTestLogNamedBytes32)
+		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 *EspressoNitroTEEVerifierTestLogNamedBytes32Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogNamedBytes32Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedBytes32 represents a LogNamedBytes32 event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedBytes32 struct {
+	Key string
+	Val [32]byte
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedBytes32 is a free log retrieval operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogNamedBytes32(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogNamedBytes32Iterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_named_bytes32")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogNamedBytes32Iterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_named_bytes32", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedBytes32 is a free log subscription operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogNamedBytes32(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogNamedBytes32) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_named_bytes32")
+	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(EspressoNitroTEEVerifierTestLogNamedBytes32)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_bytes32", 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
+}
+
+// ParseLogNamedBytes32 is a log parse operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogNamedBytes32(log types.Log) (*EspressoNitroTEEVerifierTestLogNamedBytes32, error) {
+	event := new(EspressoNitroTEEVerifierTestLogNamedBytes32)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_bytes32", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedDecimalIntIterator is returned from FilterLogNamedDecimalInt and is used to iterate over the raw logs and unpacked data for LogNamedDecimalInt events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedDecimalIntIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogNamedDecimalInt // 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 *EspressoNitroTEEVerifierTestLogNamedDecimalIntIterator) 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(EspressoNitroTEEVerifierTestLogNamedDecimalInt)
+			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(EspressoNitroTEEVerifierTestLogNamedDecimalInt)
+		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 *EspressoNitroTEEVerifierTestLogNamedDecimalIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogNamedDecimalIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedDecimalInt represents a LogNamedDecimalInt event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedDecimalInt struct {
+	Key      string
+	Val      *big.Int
+	Decimals *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedDecimalInt is a free log retrieval operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogNamedDecimalInt(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogNamedDecimalIntIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_named_decimal_int")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogNamedDecimalIntIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_named_decimal_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedDecimalInt is a free log subscription operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogNamedDecimalInt(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogNamedDecimalInt) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_named_decimal_int")
+	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(EspressoNitroTEEVerifierTestLogNamedDecimalInt)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_decimal_int", 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
+}
+
+// ParseLogNamedDecimalInt is a log parse operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogNamedDecimalInt(log types.Log) (*EspressoNitroTEEVerifierTestLogNamedDecimalInt, error) {
+	event := new(EspressoNitroTEEVerifierTestLogNamedDecimalInt)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedDecimalUintIterator is returned from FilterLogNamedDecimalUint and is used to iterate over the raw logs and unpacked data for LogNamedDecimalUint events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedDecimalUintIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogNamedDecimalUint // 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 *EspressoNitroTEEVerifierTestLogNamedDecimalUintIterator) 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(EspressoNitroTEEVerifierTestLogNamedDecimalUint)
+			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(EspressoNitroTEEVerifierTestLogNamedDecimalUint)
+		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 *EspressoNitroTEEVerifierTestLogNamedDecimalUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogNamedDecimalUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedDecimalUint represents a LogNamedDecimalUint event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedDecimalUint struct {
+	Key      string
+	Val      *big.Int
+	Decimals *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedDecimalUint is a free log retrieval operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogNamedDecimalUint(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogNamedDecimalUintIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_named_decimal_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogNamedDecimalUintIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_named_decimal_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedDecimalUint is a free log subscription operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogNamedDecimalUint(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogNamedDecimalUint) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_named_decimal_uint")
+	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(EspressoNitroTEEVerifierTestLogNamedDecimalUint)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_decimal_uint", 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
+}
+
+// ParseLogNamedDecimalUint is a log parse operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogNamedDecimalUint(log types.Log) (*EspressoNitroTEEVerifierTestLogNamedDecimalUint, error) {
+	event := new(EspressoNitroTEEVerifierTestLogNamedDecimalUint)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedIntIterator is returned from FilterLogNamedInt and is used to iterate over the raw logs and unpacked data for LogNamedInt events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedIntIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogNamedInt // 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 *EspressoNitroTEEVerifierTestLogNamedIntIterator) 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(EspressoNitroTEEVerifierTestLogNamedInt)
+			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(EspressoNitroTEEVerifierTestLogNamedInt)
+		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 *EspressoNitroTEEVerifierTestLogNamedIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogNamedIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedInt represents a LogNamedInt event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedInt struct {
+	Key string
+	Val *big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedInt is a free log retrieval operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogNamedInt(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogNamedIntIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_named_int")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogNamedIntIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_named_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedInt is a free log subscription operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogNamedInt(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogNamedInt) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_named_int")
+	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(EspressoNitroTEEVerifierTestLogNamedInt)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_int", 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
+}
+
+// ParseLogNamedInt is a log parse operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogNamedInt(log types.Log) (*EspressoNitroTEEVerifierTestLogNamedInt, error) {
+	event := new(EspressoNitroTEEVerifierTestLogNamedInt)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedStringIterator is returned from FilterLogNamedString and is used to iterate over the raw logs and unpacked data for LogNamedString events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedStringIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogNamedString // 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 *EspressoNitroTEEVerifierTestLogNamedStringIterator) 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(EspressoNitroTEEVerifierTestLogNamedString)
+			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(EspressoNitroTEEVerifierTestLogNamedString)
+		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 *EspressoNitroTEEVerifierTestLogNamedStringIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogNamedStringIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedString represents a LogNamedString event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedString struct {
+	Key string
+	Val string
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedString is a free log retrieval operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogNamedString(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogNamedStringIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_named_string")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogNamedStringIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_named_string", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedString is a free log subscription operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogNamedString(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogNamedString) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_named_string")
+	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(EspressoNitroTEEVerifierTestLogNamedString)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_string", 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
+}
+
+// ParseLogNamedString is a log parse operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogNamedString(log types.Log) (*EspressoNitroTEEVerifierTestLogNamedString, error) {
+	event := new(EspressoNitroTEEVerifierTestLogNamedString)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_string", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedUintIterator is returned from FilterLogNamedUint and is used to iterate over the raw logs and unpacked data for LogNamedUint events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedUintIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogNamedUint // 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 *EspressoNitroTEEVerifierTestLogNamedUintIterator) 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(EspressoNitroTEEVerifierTestLogNamedUint)
+			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(EspressoNitroTEEVerifierTestLogNamedUint)
+		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 *EspressoNitroTEEVerifierTestLogNamedUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogNamedUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogNamedUint represents a LogNamedUint event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogNamedUint struct {
+	Key string
+	Val *big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedUint is a free log retrieval operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogNamedUint(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogNamedUintIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_named_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogNamedUintIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_named_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedUint is a free log subscription operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogNamedUint(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogNamedUint) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_named_uint")
+	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(EspressoNitroTEEVerifierTestLogNamedUint)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_uint", 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
+}
+
+// ParseLogNamedUint is a log parse operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogNamedUint(log types.Log) (*EspressoNitroTEEVerifierTestLogNamedUint, error) {
+	event := new(EspressoNitroTEEVerifierTestLogNamedUint)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_named_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogStringIterator is returned from FilterLogString and is used to iterate over the raw logs and unpacked data for LogString events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogStringIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogString // 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 *EspressoNitroTEEVerifierTestLogStringIterator) 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(EspressoNitroTEEVerifierTestLogString)
+			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(EspressoNitroTEEVerifierTestLogString)
+		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 *EspressoNitroTEEVerifierTestLogStringIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogStringIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogString represents a LogString event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogString struct {
+	Arg0 string
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogString is a free log retrieval operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogString(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogStringIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_string")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogStringIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_string", logs: logs, sub: sub}, nil
+}
+
+// WatchLogString is a free log subscription operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogString(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogString) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_string")
+	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(EspressoNitroTEEVerifierTestLogString)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_string", 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
+}
+
+// ParseLogString is a log parse operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogString(log types.Log) (*EspressoNitroTEEVerifierTestLogString, error) {
+	event := new(EspressoNitroTEEVerifierTestLogString)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_string", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogUintIterator is returned from FilterLogUint and is used to iterate over the raw logs and unpacked data for LogUint events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogUintIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogUint // 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 *EspressoNitroTEEVerifierTestLogUintIterator) 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(EspressoNitroTEEVerifierTestLogUint)
+			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(EspressoNitroTEEVerifierTestLogUint)
+		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 *EspressoNitroTEEVerifierTestLogUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogUint represents a LogUint event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogUint struct {
+	Arg0 *big.Int
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogUint is a free log retrieval operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogUint(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogUintIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "log_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogUintIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "log_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogUint is a free log subscription operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogUint(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogUint) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "log_uint")
+	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(EspressoNitroTEEVerifierTestLogUint)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_uint", 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
+}
+
+// ParseLogUint is a log parse operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogUint(log types.Log) (*EspressoNitroTEEVerifierTestLogUint, error) {
+	event := new(EspressoNitroTEEVerifierTestLogUint)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "log_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoNitroTEEVerifierTestLogsIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for Logs events raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogsIterator struct {
+	Event *EspressoNitroTEEVerifierTestLogs // 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 *EspressoNitroTEEVerifierTestLogsIterator) 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(EspressoNitroTEEVerifierTestLogs)
+			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(EspressoNitroTEEVerifierTestLogs)
+		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 *EspressoNitroTEEVerifierTestLogsIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoNitroTEEVerifierTestLogsIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoNitroTEEVerifierTestLogs represents a Logs event raised by the EspressoNitroTEEVerifierTest contract.
+type EspressoNitroTEEVerifierTestLogs struct {
+	Arg0 []byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogs is a free log retrieval operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) FilterLogs(opts *bind.FilterOpts) (*EspressoNitroTEEVerifierTestLogsIterator, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.FilterLogs(opts, "logs")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoNitroTEEVerifierTestLogsIterator{contract: _EspressoNitroTEEVerifierTest.contract, event: "logs", logs: logs, sub: sub}, nil
+}
+
+// WatchLogs is a free log subscription operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) WatchLogs(opts *bind.WatchOpts, sink chan<- *EspressoNitroTEEVerifierTestLogs) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoNitroTEEVerifierTest.contract.WatchLogs(opts, "logs")
+	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(EspressoNitroTEEVerifierTestLogs)
+				if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "logs", 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
+}
+
+// ParseLogs is a log parse operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_EspressoNitroTEEVerifierTest *EspressoNitroTEEVerifierTestFilterer) ParseLogs(log types.Log) (*EspressoNitroTEEVerifierTestLogs, error) {
+	event := new(EspressoNitroTEEVerifierTestLogs)
+	if err := _EspressoNitroTEEVerifierTest.contract.UnpackLog(event, "logs", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerMetaData contains all meta data concerning the EspressoRollupSequencerManager contract.
+var EspressoRollupSequencerManagerMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"initialSequencers\",\"type\":\"address[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"currentSequencerCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"viewNumber\",\"type\":\"uint256\"}],\"name\":\"getCurrentSequencer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"globalNonce\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"}],\"name\":\"insertSequencer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"nonceToSequencer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"}],\"name\":\"removeSequencer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"sequencerToNonce\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"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\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"SequencerAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"SequencerRemoved\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"InvalidSequencer\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequencerAlreadyExists\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequencerDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequencerListIsEmpty\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Unauthorized\",\"type\":\"error\"}]",
+	Bin: "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",
+}
+
+// EspressoRollupSequencerManagerABI is the input ABI used to generate the binding from.
+// Deprecated: Use EspressoRollupSequencerManagerMetaData.ABI instead.
+var EspressoRollupSequencerManagerABI = EspressoRollupSequencerManagerMetaData.ABI
+
+// EspressoRollupSequencerManagerBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use EspressoRollupSequencerManagerMetaData.Bin instead.
+var EspressoRollupSequencerManagerBin = EspressoRollupSequencerManagerMetaData.Bin
+
+// DeployEspressoRollupSequencerManager deploys a new Ethereum contract, binding an instance of EspressoRollupSequencerManager to it.
+func DeployEspressoRollupSequencerManager(auth *bind.TransactOpts, backend bind.ContractBackend, initialSequencers []common.Address) (common.Address, *types.Transaction, *EspressoRollupSequencerManager, error) {
+	parsed, err := EspressoRollupSequencerManagerMetaData.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(EspressoRollupSequencerManagerBin), backend, initialSequencers)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &EspressoRollupSequencerManager{EspressoRollupSequencerManagerCaller: EspressoRollupSequencerManagerCaller{contract: contract}, EspressoRollupSequencerManagerTransactor: EspressoRollupSequencerManagerTransactor{contract: contract}, EspressoRollupSequencerManagerFilterer: EspressoRollupSequencerManagerFilterer{contract: contract}}, nil
+}
+
+// EspressoRollupSequencerManager is an auto generated Go binding around an Ethereum contract.
+type EspressoRollupSequencerManager struct {
+	EspressoRollupSequencerManagerCaller     // Read-only binding to the contract
+	EspressoRollupSequencerManagerTransactor // Write-only binding to the contract
+	EspressoRollupSequencerManagerFilterer   // Log filterer for contract events
+}
+
+// EspressoRollupSequencerManagerCaller is an auto generated read-only Go binding around an Ethereum contract.
+type EspressoRollupSequencerManagerCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoRollupSequencerManagerTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type EspressoRollupSequencerManagerTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoRollupSequencerManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type EspressoRollupSequencerManagerFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoRollupSequencerManagerSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type EspressoRollupSequencerManagerSession struct {
+	Contract     *EspressoRollupSequencerManager // 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
+}
+
+// EspressoRollupSequencerManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type EspressoRollupSequencerManagerCallerSession struct {
+	Contract *EspressoRollupSequencerManagerCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts                         // Call options to use throughout this session
+}
+
+// EspressoRollupSequencerManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type EspressoRollupSequencerManagerTransactorSession struct {
+	Contract     *EspressoRollupSequencerManagerTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts                         // Transaction auth options to use throughout this session
+}
+
+// EspressoRollupSequencerManagerRaw is an auto generated low-level Go binding around an Ethereum contract.
+type EspressoRollupSequencerManagerRaw struct {
+	Contract *EspressoRollupSequencerManager // Generic contract binding to access the raw methods on
+}
+
+// EspressoRollupSequencerManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type EspressoRollupSequencerManagerCallerRaw struct {
+	Contract *EspressoRollupSequencerManagerCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// EspressoRollupSequencerManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type EspressoRollupSequencerManagerTransactorRaw struct {
+	Contract *EspressoRollupSequencerManagerTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewEspressoRollupSequencerManager creates a new instance of EspressoRollupSequencerManager, bound to a specific deployed contract.
+func NewEspressoRollupSequencerManager(address common.Address, backend bind.ContractBackend) (*EspressoRollupSequencerManager, error) {
+	contract, err := bindEspressoRollupSequencerManager(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManager{EspressoRollupSequencerManagerCaller: EspressoRollupSequencerManagerCaller{contract: contract}, EspressoRollupSequencerManagerTransactor: EspressoRollupSequencerManagerTransactor{contract: contract}, EspressoRollupSequencerManagerFilterer: EspressoRollupSequencerManagerFilterer{contract: contract}}, nil
+}
+
+// NewEspressoRollupSequencerManagerCaller creates a new read-only instance of EspressoRollupSequencerManager, bound to a specific deployed contract.
+func NewEspressoRollupSequencerManagerCaller(address common.Address, caller bind.ContractCaller) (*EspressoRollupSequencerManagerCaller, error) {
+	contract, err := bindEspressoRollupSequencerManager(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerCaller{contract: contract}, nil
+}
+
+// NewEspressoRollupSequencerManagerTransactor creates a new write-only instance of EspressoRollupSequencerManager, bound to a specific deployed contract.
+func NewEspressoRollupSequencerManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*EspressoRollupSequencerManagerTransactor, error) {
+	contract, err := bindEspressoRollupSequencerManager(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTransactor{contract: contract}, nil
+}
+
+// NewEspressoRollupSequencerManagerFilterer creates a new log filterer instance of EspressoRollupSequencerManager, bound to a specific deployed contract.
+func NewEspressoRollupSequencerManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*EspressoRollupSequencerManagerFilterer, error) {
+	contract, err := bindEspressoRollupSequencerManager(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerFilterer{contract: contract}, nil
+}
+
+// bindEspressoRollupSequencerManager binds a generic wrapper to an already deployed contract.
+func bindEspressoRollupSequencerManager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := EspressoRollupSequencerManagerMetaData.GetAbi()
+	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 (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoRollupSequencerManager.Contract.EspressoRollupSequencerManagerCaller.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 (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.EspressoRollupSequencerManagerTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.EspressoRollupSequencerManagerTransactor.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 (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoRollupSequencerManager.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 (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.contract.Transact(opts, method, params...)
+}
+
+// CurrentSequencerCount is a free data retrieval call binding the contract method 0x35c82c95.
+//
+// Solidity: function currentSequencerCount() view returns(uint256)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCaller) CurrentSequencerCount(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManager.contract.Call(opts, &out, "currentSequencerCount")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// CurrentSequencerCount is a free data retrieval call binding the contract method 0x35c82c95.
+//
+// Solidity: function currentSequencerCount() view returns(uint256)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerSession) CurrentSequencerCount() (*big.Int, error) {
+	return _EspressoRollupSequencerManager.Contract.CurrentSequencerCount(&_EspressoRollupSequencerManager.CallOpts)
+}
+
+// CurrentSequencerCount is a free data retrieval call binding the contract method 0x35c82c95.
+//
+// Solidity: function currentSequencerCount() view returns(uint256)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCallerSession) CurrentSequencerCount() (*big.Int, error) {
+	return _EspressoRollupSequencerManager.Contract.CurrentSequencerCount(&_EspressoRollupSequencerManager.CallOpts)
+}
+
+// GetCurrentSequencer is a free data retrieval call binding the contract method 0x25cb5685.
+//
+// Solidity: function getCurrentSequencer(uint256 viewNumber) view returns(address)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCaller) GetCurrentSequencer(opts *bind.CallOpts, viewNumber *big.Int) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManager.contract.Call(opts, &out, "getCurrentSequencer", viewNumber)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// GetCurrentSequencer is a free data retrieval call binding the contract method 0x25cb5685.
+//
+// Solidity: function getCurrentSequencer(uint256 viewNumber) view returns(address)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerSession) GetCurrentSequencer(viewNumber *big.Int) (common.Address, error) {
+	return _EspressoRollupSequencerManager.Contract.GetCurrentSequencer(&_EspressoRollupSequencerManager.CallOpts, viewNumber)
+}
+
+// GetCurrentSequencer is a free data retrieval call binding the contract method 0x25cb5685.
+//
+// Solidity: function getCurrentSequencer(uint256 viewNumber) view returns(address)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCallerSession) GetCurrentSequencer(viewNumber *big.Int) (common.Address, error) {
+	return _EspressoRollupSequencerManager.Contract.GetCurrentSequencer(&_EspressoRollupSequencerManager.CallOpts, viewNumber)
+}
+
+// GlobalNonce is a free data retrieval call binding the contract method 0x37e23222.
+//
+// Solidity: function globalNonce() view returns(uint256)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCaller) GlobalNonce(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManager.contract.Call(opts, &out, "globalNonce")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GlobalNonce is a free data retrieval call binding the contract method 0x37e23222.
+//
+// Solidity: function globalNonce() view returns(uint256)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerSession) GlobalNonce() (*big.Int, error) {
+	return _EspressoRollupSequencerManager.Contract.GlobalNonce(&_EspressoRollupSequencerManager.CallOpts)
+}
+
+// GlobalNonce is a free data retrieval call binding the contract method 0x37e23222.
+//
+// Solidity: function globalNonce() view returns(uint256)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCallerSession) GlobalNonce() (*big.Int, error) {
+	return _EspressoRollupSequencerManager.Contract.GlobalNonce(&_EspressoRollupSequencerManager.CallOpts)
+}
+
+// NonceToSequencer is a free data retrieval call binding the contract method 0xf39b1a7c.
+//
+// Solidity: function nonceToSequencer(uint256 ) view returns(address)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCaller) NonceToSequencer(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManager.contract.Call(opts, &out, "nonceToSequencer", arg0)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// NonceToSequencer is a free data retrieval call binding the contract method 0xf39b1a7c.
+//
+// Solidity: function nonceToSequencer(uint256 ) view returns(address)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerSession) NonceToSequencer(arg0 *big.Int) (common.Address, error) {
+	return _EspressoRollupSequencerManager.Contract.NonceToSequencer(&_EspressoRollupSequencerManager.CallOpts, arg0)
+}
+
+// NonceToSequencer is a free data retrieval call binding the contract method 0xf39b1a7c.
+//
+// Solidity: function nonceToSequencer(uint256 ) view returns(address)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCallerSession) NonceToSequencer(arg0 *big.Int) (common.Address, error) {
+	return _EspressoRollupSequencerManager.Contract.NonceToSequencer(&_EspressoRollupSequencerManager.CallOpts, arg0)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManager.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 (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerSession) Owner() (common.Address, error) {
+	return _EspressoRollupSequencerManager.Contract.Owner(&_EspressoRollupSequencerManager.CallOpts)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCallerSession) Owner() (common.Address, error) {
+	return _EspressoRollupSequencerManager.Contract.Owner(&_EspressoRollupSequencerManager.CallOpts)
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCaller) PendingOwner(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManager.contract.Call(opts, &out, "pendingOwner")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerSession) PendingOwner() (common.Address, error) {
+	return _EspressoRollupSequencerManager.Contract.PendingOwner(&_EspressoRollupSequencerManager.CallOpts)
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCallerSession) PendingOwner() (common.Address, error) {
+	return _EspressoRollupSequencerManager.Contract.PendingOwner(&_EspressoRollupSequencerManager.CallOpts)
+}
+
+// SequencerToNonce is a free data retrieval call binding the contract method 0xaadd00fb.
+//
+// Solidity: function sequencerToNonce(address ) view returns(uint256)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCaller) SequencerToNonce(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManager.contract.Call(opts, &out, "sequencerToNonce", arg0)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// SequencerToNonce is a free data retrieval call binding the contract method 0xaadd00fb.
+//
+// Solidity: function sequencerToNonce(address ) view returns(uint256)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerSession) SequencerToNonce(arg0 common.Address) (*big.Int, error) {
+	return _EspressoRollupSequencerManager.Contract.SequencerToNonce(&_EspressoRollupSequencerManager.CallOpts, arg0)
+}
+
+// SequencerToNonce is a free data retrieval call binding the contract method 0xaadd00fb.
+//
+// Solidity: function sequencerToNonce(address ) view returns(uint256)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerCallerSession) SequencerToNonce(arg0 common.Address) (*big.Int, error) {
+	return _EspressoRollupSequencerManager.Contract.SequencerToNonce(&_EspressoRollupSequencerManager.CallOpts, arg0)
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerTransactor) AcceptOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.contract.Transact(opts, "acceptOwnership")
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerSession) AcceptOwnership() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.AcceptOwnership(&_EspressoRollupSequencerManager.TransactOpts)
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerTransactorSession) AcceptOwnership() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.AcceptOwnership(&_EspressoRollupSequencerManager.TransactOpts)
+}
+
+// InsertSequencer is a paid mutator transaction binding the contract method 0xa5b41b73.
+//
+// Solidity: function insertSequencer(address sequencer) returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerTransactor) InsertSequencer(opts *bind.TransactOpts, sequencer common.Address) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.contract.Transact(opts, "insertSequencer", sequencer)
+}
+
+// InsertSequencer is a paid mutator transaction binding the contract method 0xa5b41b73.
+//
+// Solidity: function insertSequencer(address sequencer) returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerSession) InsertSequencer(sequencer common.Address) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.InsertSequencer(&_EspressoRollupSequencerManager.TransactOpts, sequencer)
+}
+
+// InsertSequencer is a paid mutator transaction binding the contract method 0xa5b41b73.
+//
+// Solidity: function insertSequencer(address sequencer) returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerTransactorSession) InsertSequencer(sequencer common.Address) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.InsertSequencer(&_EspressoRollupSequencerManager.TransactOpts, sequencer)
+}
+
+// RemoveSequencer is a paid mutator transaction binding the contract method 0x6989ca7c.
+//
+// Solidity: function removeSequencer(address sequencer) returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerTransactor) RemoveSequencer(opts *bind.TransactOpts, sequencer common.Address) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.contract.Transact(opts, "removeSequencer", sequencer)
+}
+
+// RemoveSequencer is a paid mutator transaction binding the contract method 0x6989ca7c.
+//
+// Solidity: function removeSequencer(address sequencer) returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerSession) RemoveSequencer(sequencer common.Address) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.RemoveSequencer(&_EspressoRollupSequencerManager.TransactOpts, sequencer)
+}
+
+// RemoveSequencer is a paid mutator transaction binding the contract method 0x6989ca7c.
+//
+// Solidity: function removeSequencer(address sequencer) returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerTransactorSession) RemoveSequencer(sequencer common.Address) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.RemoveSequencer(&_EspressoRollupSequencerManager.TransactOpts, sequencer)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.contract.Transact(opts, "renounceOwnership")
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerSession) RenounceOwnership() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.RenounceOwnership(&_EspressoRollupSequencerManager.TransactOpts)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerTransactorSession) RenounceOwnership() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.RenounceOwnership(&_EspressoRollupSequencerManager.TransactOpts)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.contract.Transact(opts, "transferOwnership", newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.TransferOwnership(&_EspressoRollupSequencerManager.TransactOpts, newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManager.Contract.TransferOwnership(&_EspressoRollupSequencerManager.TransactOpts, newOwner)
+}
+
+// EspressoRollupSequencerManagerOwnershipTransferStartedIterator is returned from FilterOwnershipTransferStarted and is used to iterate over the raw logs and unpacked data for OwnershipTransferStarted events raised by the EspressoRollupSequencerManager contract.
+type EspressoRollupSequencerManagerOwnershipTransferStartedIterator struct {
+	Event *EspressoRollupSequencerManagerOwnershipTransferStarted // 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 *EspressoRollupSequencerManagerOwnershipTransferStartedIterator) 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(EspressoRollupSequencerManagerOwnershipTransferStarted)
+			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(EspressoRollupSequencerManagerOwnershipTransferStarted)
+		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 *EspressoRollupSequencerManagerOwnershipTransferStartedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerOwnershipTransferStartedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerOwnershipTransferStarted represents a OwnershipTransferStarted event raised by the EspressoRollupSequencerManager contract.
+type EspressoRollupSequencerManagerOwnershipTransferStarted struct {
+	PreviousOwner common.Address
+	NewOwner      common.Address
+	Raw           types.Log // Blockchain specific contextual infos
+}
+
+// FilterOwnershipTransferStarted is a free log retrieval operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerFilterer) FilterOwnershipTransferStarted(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*EspressoRollupSequencerManagerOwnershipTransferStartedIterator, 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 := _EspressoRollupSequencerManager.contract.FilterLogs(opts, "OwnershipTransferStarted", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerOwnershipTransferStartedIterator{contract: _EspressoRollupSequencerManager.contract, event: "OwnershipTransferStarted", logs: logs, sub: sub}, nil
+}
+
+// WatchOwnershipTransferStarted is a free log subscription operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerFilterer) WatchOwnershipTransferStarted(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerOwnershipTransferStarted, 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 := _EspressoRollupSequencerManager.contract.WatchLogs(opts, "OwnershipTransferStarted", 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(EspressoRollupSequencerManagerOwnershipTransferStarted)
+				if err := _EspressoRollupSequencerManager.contract.UnpackLog(event, "OwnershipTransferStarted", 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
+}
+
+// ParseOwnershipTransferStarted is a log parse operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerFilterer) ParseOwnershipTransferStarted(log types.Log) (*EspressoRollupSequencerManagerOwnershipTransferStarted, error) {
+	event := new(EspressoRollupSequencerManagerOwnershipTransferStarted)
+	if err := _EspressoRollupSequencerManager.contract.UnpackLog(event, "OwnershipTransferStarted", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the EspressoRollupSequencerManager contract.
+type EspressoRollupSequencerManagerOwnershipTransferredIterator struct {
+	Event *EspressoRollupSequencerManagerOwnershipTransferred // 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 *EspressoRollupSequencerManagerOwnershipTransferredIterator) 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(EspressoRollupSequencerManagerOwnershipTransferred)
+			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(EspressoRollupSequencerManagerOwnershipTransferred)
+		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 *EspressoRollupSequencerManagerOwnershipTransferredIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerOwnershipTransferredIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerOwnershipTransferred represents a OwnershipTransferred event raised by the EspressoRollupSequencerManager contract.
+type EspressoRollupSequencerManagerOwnershipTransferred 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 (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*EspressoRollupSequencerManagerOwnershipTransferredIterator, 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 := _EspressoRollupSequencerManager.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerOwnershipTransferredIterator{contract: _EspressoRollupSequencerManager.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 (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerOwnershipTransferred, 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 := _EspressoRollupSequencerManager.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(EspressoRollupSequencerManagerOwnershipTransferred)
+				if err := _EspressoRollupSequencerManager.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 (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerFilterer) ParseOwnershipTransferred(log types.Log) (*EspressoRollupSequencerManagerOwnershipTransferred, error) {
+	event := new(EspressoRollupSequencerManagerOwnershipTransferred)
+	if err := _EspressoRollupSequencerManager.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerSequencerAddedIterator is returned from FilterSequencerAdded and is used to iterate over the raw logs and unpacked data for SequencerAdded events raised by the EspressoRollupSequencerManager contract.
+type EspressoRollupSequencerManagerSequencerAddedIterator struct {
+	Event *EspressoRollupSequencerManagerSequencerAdded // 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 *EspressoRollupSequencerManagerSequencerAddedIterator) 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(EspressoRollupSequencerManagerSequencerAdded)
+			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(EspressoRollupSequencerManagerSequencerAdded)
+		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 *EspressoRollupSequencerManagerSequencerAddedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerSequencerAddedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerSequencerAdded represents a SequencerAdded event raised by the EspressoRollupSequencerManager contract.
+type EspressoRollupSequencerManagerSequencerAdded struct {
+	Sequencer common.Address
+	Nonce     *big.Int
+	Raw       types.Log // Blockchain specific contextual infos
+}
+
+// FilterSequencerAdded is a free log retrieval operation binding the contract event 0x4fd176ea5a84f3047cc893049bb44ef7418b01c9e07affb753a6847a9cfd6a66.
+//
+// Solidity: event SequencerAdded(address indexed sequencer, uint256 indexed nonce)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerFilterer) FilterSequencerAdded(opts *bind.FilterOpts, sequencer []common.Address, nonce []*big.Int) (*EspressoRollupSequencerManagerSequencerAddedIterator, error) {
+
+	var sequencerRule []interface{}
+	for _, sequencerItem := range sequencer {
+		sequencerRule = append(sequencerRule, sequencerItem)
+	}
+	var nonceRule []interface{}
+	for _, nonceItem := range nonce {
+		nonceRule = append(nonceRule, nonceItem)
+	}
+
+	logs, sub, err := _EspressoRollupSequencerManager.contract.FilterLogs(opts, "SequencerAdded", sequencerRule, nonceRule)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerSequencerAddedIterator{contract: _EspressoRollupSequencerManager.contract, event: "SequencerAdded", logs: logs, sub: sub}, nil
+}
+
+// WatchSequencerAdded is a free log subscription operation binding the contract event 0x4fd176ea5a84f3047cc893049bb44ef7418b01c9e07affb753a6847a9cfd6a66.
+//
+// Solidity: event SequencerAdded(address indexed sequencer, uint256 indexed nonce)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerFilterer) WatchSequencerAdded(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerSequencerAdded, sequencer []common.Address, nonce []*big.Int) (event.Subscription, error) {
+
+	var sequencerRule []interface{}
+	for _, sequencerItem := range sequencer {
+		sequencerRule = append(sequencerRule, sequencerItem)
+	}
+	var nonceRule []interface{}
+	for _, nonceItem := range nonce {
+		nonceRule = append(nonceRule, nonceItem)
+	}
+
+	logs, sub, err := _EspressoRollupSequencerManager.contract.WatchLogs(opts, "SequencerAdded", sequencerRule, nonceRule)
+	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(EspressoRollupSequencerManagerSequencerAdded)
+				if err := _EspressoRollupSequencerManager.contract.UnpackLog(event, "SequencerAdded", 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
+}
+
+// ParseSequencerAdded is a log parse operation binding the contract event 0x4fd176ea5a84f3047cc893049bb44ef7418b01c9e07affb753a6847a9cfd6a66.
+//
+// Solidity: event SequencerAdded(address indexed sequencer, uint256 indexed nonce)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerFilterer) ParseSequencerAdded(log types.Log) (*EspressoRollupSequencerManagerSequencerAdded, error) {
+	event := new(EspressoRollupSequencerManagerSequencerAdded)
+	if err := _EspressoRollupSequencerManager.contract.UnpackLog(event, "SequencerAdded", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerSequencerRemovedIterator is returned from FilterSequencerRemoved and is used to iterate over the raw logs and unpacked data for SequencerRemoved events raised by the EspressoRollupSequencerManager contract.
+type EspressoRollupSequencerManagerSequencerRemovedIterator struct {
+	Event *EspressoRollupSequencerManagerSequencerRemoved // 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 *EspressoRollupSequencerManagerSequencerRemovedIterator) 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(EspressoRollupSequencerManagerSequencerRemoved)
+			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(EspressoRollupSequencerManagerSequencerRemoved)
+		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 *EspressoRollupSequencerManagerSequencerRemovedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerSequencerRemovedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerSequencerRemoved represents a SequencerRemoved event raised by the EspressoRollupSequencerManager contract.
+type EspressoRollupSequencerManagerSequencerRemoved struct {
+	Sequencer common.Address
+	Nonce     *big.Int
+	Raw       types.Log // Blockchain specific contextual infos
+}
+
+// FilterSequencerRemoved is a free log retrieval operation binding the contract event 0x211a133ec451de7013a054ec41eb8fa07df65089fda546cbaa7a0cffa08375bc.
+//
+// Solidity: event SequencerRemoved(address indexed sequencer, uint256 indexed nonce)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerFilterer) FilterSequencerRemoved(opts *bind.FilterOpts, sequencer []common.Address, nonce []*big.Int) (*EspressoRollupSequencerManagerSequencerRemovedIterator, error) {
+
+	var sequencerRule []interface{}
+	for _, sequencerItem := range sequencer {
+		sequencerRule = append(sequencerRule, sequencerItem)
+	}
+	var nonceRule []interface{}
+	for _, nonceItem := range nonce {
+		nonceRule = append(nonceRule, nonceItem)
+	}
+
+	logs, sub, err := _EspressoRollupSequencerManager.contract.FilterLogs(opts, "SequencerRemoved", sequencerRule, nonceRule)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerSequencerRemovedIterator{contract: _EspressoRollupSequencerManager.contract, event: "SequencerRemoved", logs: logs, sub: sub}, nil
+}
+
+// WatchSequencerRemoved is a free log subscription operation binding the contract event 0x211a133ec451de7013a054ec41eb8fa07df65089fda546cbaa7a0cffa08375bc.
+//
+// Solidity: event SequencerRemoved(address indexed sequencer, uint256 indexed nonce)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerFilterer) WatchSequencerRemoved(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerSequencerRemoved, sequencer []common.Address, nonce []*big.Int) (event.Subscription, error) {
+
+	var sequencerRule []interface{}
+	for _, sequencerItem := range sequencer {
+		sequencerRule = append(sequencerRule, sequencerItem)
+	}
+	var nonceRule []interface{}
+	for _, nonceItem := range nonce {
+		nonceRule = append(nonceRule, nonceItem)
+	}
+
+	logs, sub, err := _EspressoRollupSequencerManager.contract.WatchLogs(opts, "SequencerRemoved", sequencerRule, nonceRule)
+	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(EspressoRollupSequencerManagerSequencerRemoved)
+				if err := _EspressoRollupSequencerManager.contract.UnpackLog(event, "SequencerRemoved", 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
+}
+
+// ParseSequencerRemoved is a log parse operation binding the contract event 0x211a133ec451de7013a054ec41eb8fa07df65089fda546cbaa7a0cffa08375bc.
+//
+// Solidity: event SequencerRemoved(address indexed sequencer, uint256 indexed nonce)
+func (_EspressoRollupSequencerManager *EspressoRollupSequencerManagerFilterer) ParseSequencerRemoved(log types.Log) (*EspressoRollupSequencerManagerSequencerRemoved, error) {
+	event := new(EspressoRollupSequencerManagerSequencerRemoved)
+	if err := _EspressoRollupSequencerManager.contract.UnpackLog(event, "SequencerRemoved", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestMetaData contains all meta data concerning the EspressoRollupSequencerManagerTest contract.
+var EspressoRollupSequencerManagerTestMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"initialSequencers\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rollupSequencerManager\",\"outputs\":[{\"internalType\":\"contractEspressoRollupSequencerManager\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testGetCurrentSequencer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testGetCurrentSequencerFailsIViewNumberGreaterThanSequencerLength\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testInsertFailsIfNotAuthorized\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testInsertSequencer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testInsertSequencerFailsIfSequencerAlreadyExists\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testRemoveSequencer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testRemoveSequencerFailsIfNotAuthorized\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testRemoveSequencerFailsIfSequencerDoesNotExist\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"SequencerAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"SequencerRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"}]",
+	Bin: "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",
+}
+
+// EspressoRollupSequencerManagerTestABI is the input ABI used to generate the binding from.
+// Deprecated: Use EspressoRollupSequencerManagerTestMetaData.ABI instead.
+var EspressoRollupSequencerManagerTestABI = EspressoRollupSequencerManagerTestMetaData.ABI
+
+// EspressoRollupSequencerManagerTestBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use EspressoRollupSequencerManagerTestMetaData.Bin instead.
+var EspressoRollupSequencerManagerTestBin = EspressoRollupSequencerManagerTestMetaData.Bin
+
+// DeployEspressoRollupSequencerManagerTest deploys a new Ethereum contract, binding an instance of EspressoRollupSequencerManagerTest to it.
+func DeployEspressoRollupSequencerManagerTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *EspressoRollupSequencerManagerTest, error) {
+	parsed, err := EspressoRollupSequencerManagerTestMetaData.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(EspressoRollupSequencerManagerTestBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &EspressoRollupSequencerManagerTest{EspressoRollupSequencerManagerTestCaller: EspressoRollupSequencerManagerTestCaller{contract: contract}, EspressoRollupSequencerManagerTestTransactor: EspressoRollupSequencerManagerTestTransactor{contract: contract}, EspressoRollupSequencerManagerTestFilterer: EspressoRollupSequencerManagerTestFilterer{contract: contract}}, nil
+}
+
+// EspressoRollupSequencerManagerTest is an auto generated Go binding around an Ethereum contract.
+type EspressoRollupSequencerManagerTest struct {
+	EspressoRollupSequencerManagerTestCaller     // Read-only binding to the contract
+	EspressoRollupSequencerManagerTestTransactor // Write-only binding to the contract
+	EspressoRollupSequencerManagerTestFilterer   // Log filterer for contract events
+}
+
+// EspressoRollupSequencerManagerTestCaller is an auto generated read-only Go binding around an Ethereum contract.
+type EspressoRollupSequencerManagerTestCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoRollupSequencerManagerTestTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type EspressoRollupSequencerManagerTestTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoRollupSequencerManagerTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type EspressoRollupSequencerManagerTestFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoRollupSequencerManagerTestSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type EspressoRollupSequencerManagerTestSession struct {
+	Contract     *EspressoRollupSequencerManagerTest // 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
+}
+
+// EspressoRollupSequencerManagerTestCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type EspressoRollupSequencerManagerTestCallerSession struct {
+	Contract *EspressoRollupSequencerManagerTestCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts                             // Call options to use throughout this session
+}
+
+// EspressoRollupSequencerManagerTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type EspressoRollupSequencerManagerTestTransactorSession struct {
+	Contract     *EspressoRollupSequencerManagerTestTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts                             // Transaction auth options to use throughout this session
+}
+
+// EspressoRollupSequencerManagerTestRaw is an auto generated low-level Go binding around an Ethereum contract.
+type EspressoRollupSequencerManagerTestRaw struct {
+	Contract *EspressoRollupSequencerManagerTest // Generic contract binding to access the raw methods on
+}
+
+// EspressoRollupSequencerManagerTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type EspressoRollupSequencerManagerTestCallerRaw struct {
+	Contract *EspressoRollupSequencerManagerTestCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// EspressoRollupSequencerManagerTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type EspressoRollupSequencerManagerTestTransactorRaw struct {
+	Contract *EspressoRollupSequencerManagerTestTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewEspressoRollupSequencerManagerTest creates a new instance of EspressoRollupSequencerManagerTest, bound to a specific deployed contract.
+func NewEspressoRollupSequencerManagerTest(address common.Address, backend bind.ContractBackend) (*EspressoRollupSequencerManagerTest, error) {
+	contract, err := bindEspressoRollupSequencerManagerTest(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTest{EspressoRollupSequencerManagerTestCaller: EspressoRollupSequencerManagerTestCaller{contract: contract}, EspressoRollupSequencerManagerTestTransactor: EspressoRollupSequencerManagerTestTransactor{contract: contract}, EspressoRollupSequencerManagerTestFilterer: EspressoRollupSequencerManagerTestFilterer{contract: contract}}, nil
+}
+
+// NewEspressoRollupSequencerManagerTestCaller creates a new read-only instance of EspressoRollupSequencerManagerTest, bound to a specific deployed contract.
+func NewEspressoRollupSequencerManagerTestCaller(address common.Address, caller bind.ContractCaller) (*EspressoRollupSequencerManagerTestCaller, error) {
+	contract, err := bindEspressoRollupSequencerManagerTest(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestCaller{contract: contract}, nil
+}
+
+// NewEspressoRollupSequencerManagerTestTransactor creates a new write-only instance of EspressoRollupSequencerManagerTest, bound to a specific deployed contract.
+func NewEspressoRollupSequencerManagerTestTransactor(address common.Address, transactor bind.ContractTransactor) (*EspressoRollupSequencerManagerTestTransactor, error) {
+	contract, err := bindEspressoRollupSequencerManagerTest(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestTransactor{contract: contract}, nil
+}
+
+// NewEspressoRollupSequencerManagerTestFilterer creates a new log filterer instance of EspressoRollupSequencerManagerTest, bound to a specific deployed contract.
+func NewEspressoRollupSequencerManagerTestFilterer(address common.Address, filterer bind.ContractFilterer) (*EspressoRollupSequencerManagerTestFilterer, error) {
+	contract, err := bindEspressoRollupSequencerManagerTest(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestFilterer{contract: contract}, nil
+}
+
+// bindEspressoRollupSequencerManagerTest binds a generic wrapper to an already deployed contract.
+func bindEspressoRollupSequencerManagerTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := EspressoRollupSequencerManagerTestMetaData.GetAbi()
+	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 (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoRollupSequencerManagerTest.Contract.EspressoRollupSequencerManagerTestCaller.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 (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.EspressoRollupSequencerManagerTestTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.EspressoRollupSequencerManagerTestTransactor.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 (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoRollupSequencerManagerTest.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 (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.contract.Transact(opts, method, params...)
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) ISTEST(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "IS_TEST")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) ISTEST() (bool, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.ISTEST(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) ISTEST() (bool, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.ISTEST(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) ExcludeArtifacts(opts *bind.CallOpts) ([]string, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "excludeArtifacts")
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) ExcludeArtifacts() ([]string, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.ExcludeArtifacts(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) ExcludeArtifacts() ([]string, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.ExcludeArtifacts(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) ExcludeContracts(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "excludeContracts")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) ExcludeContracts() ([]common.Address, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.ExcludeContracts(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) ExcludeContracts() ([]common.Address, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.ExcludeContracts(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) ExcludeSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "excludeSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector)
+
+	return out0, err
+
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.ExcludeSelectors(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.ExcludeSelectors(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) ExcludeSenders(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "excludeSenders")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) ExcludeSenders() ([]common.Address, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.ExcludeSenders(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) ExcludeSenders() ([]common.Address, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.ExcludeSenders(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) Failed(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "failed")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) Failed() (bool, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.Failed(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) Failed() (bool, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.Failed(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// InitialSequencers is a free data retrieval call binding the contract method 0x998c3cdf.
+//
+// Solidity: function initialSequencers(uint256 ) view returns(address)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) InitialSequencers(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "initialSequencers", arg0)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// InitialSequencers is a free data retrieval call binding the contract method 0x998c3cdf.
+//
+// Solidity: function initialSequencers(uint256 ) view returns(address)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) InitialSequencers(arg0 *big.Int) (common.Address, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.InitialSequencers(&_EspressoRollupSequencerManagerTest.CallOpts, arg0)
+}
+
+// InitialSequencers is a free data retrieval call binding the contract method 0x998c3cdf.
+//
+// Solidity: function initialSequencers(uint256 ) view returns(address)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) InitialSequencers(arg0 *big.Int) (common.Address, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.InitialSequencers(&_EspressoRollupSequencerManagerTest.CallOpts, arg0)
+}
+
+// RollupSequencerManager is a free data retrieval call binding the contract method 0x82e3e59b.
+//
+// Solidity: function rollupSequencerManager() view returns(address)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) RollupSequencerManager(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "rollupSequencerManager")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// RollupSequencerManager is a free data retrieval call binding the contract method 0x82e3e59b.
+//
+// Solidity: function rollupSequencerManager() view returns(address)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) RollupSequencerManager() (common.Address, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.RollupSequencerManager(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// RollupSequencerManager is a free data retrieval call binding the contract method 0x82e3e59b.
+//
+// Solidity: function rollupSequencerManager() view returns(address)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) RollupSequencerManager() (common.Address, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.RollupSequencerManager(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) TargetArtifactSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzArtifactSelector, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "targetArtifactSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzArtifactSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzArtifactSelector)).(*[]StdInvariantFuzzArtifactSelector)
+
+	return out0, err
+
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TargetArtifactSelectors(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TargetArtifactSelectors(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) TargetArtifacts(opts *bind.CallOpts) ([]string, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "targetArtifacts")
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TargetArtifacts() ([]string, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TargetArtifacts(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) TargetArtifacts() ([]string, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TargetArtifacts(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) TargetContracts(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "targetContracts")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TargetContracts() ([]common.Address, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TargetContracts(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) TargetContracts() ([]common.Address, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TargetContracts(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) TargetInterfaces(opts *bind.CallOpts) ([]StdInvariantFuzzInterface, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "targetInterfaces")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzInterface), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzInterface)).(*[]StdInvariantFuzzInterface)
+
+	return out0, err
+
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TargetInterfaces(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TargetInterfaces(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) TargetSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "targetSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector)
+
+	return out0, err
+
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TargetSelectors(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TargetSelectors(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCaller) TargetSenders(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoRollupSequencerManagerTest.contract.Call(opts, &out, "targetSenders")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TargetSenders() ([]common.Address, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TargetSenders(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestCallerSession) TargetSenders() ([]common.Address, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TargetSenders(&_EspressoRollupSequencerManagerTest.CallOpts)
+}
+
+// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4.
+//
+// Solidity: function setUp() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactor) SetUp(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.contract.Transact(opts, "setUp")
+}
+
+// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4.
+//
+// Solidity: function setUp() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) SetUp() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.SetUp(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4.
+//
+// Solidity: function setUp() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactorSession) SetUp() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.SetUp(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestGetCurrentSequencer is a paid mutator transaction binding the contract method 0x5bae3015.
+//
+// Solidity: function testGetCurrentSequencer() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactor) TestGetCurrentSequencer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.contract.Transact(opts, "testGetCurrentSequencer")
+}
+
+// TestGetCurrentSequencer is a paid mutator transaction binding the contract method 0x5bae3015.
+//
+// Solidity: function testGetCurrentSequencer() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TestGetCurrentSequencer() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestGetCurrentSequencer(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestGetCurrentSequencer is a paid mutator transaction binding the contract method 0x5bae3015.
+//
+// Solidity: function testGetCurrentSequencer() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactorSession) TestGetCurrentSequencer() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestGetCurrentSequencer(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestGetCurrentSequencerFailsIViewNumberGreaterThanSequencerLength is a paid mutator transaction binding the contract method 0x03d9087d.
+//
+// Solidity: function testGetCurrentSequencerFailsIViewNumberGreaterThanSequencerLength() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactor) TestGetCurrentSequencerFailsIViewNumberGreaterThanSequencerLength(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.contract.Transact(opts, "testGetCurrentSequencerFailsIViewNumberGreaterThanSequencerLength")
+}
+
+// TestGetCurrentSequencerFailsIViewNumberGreaterThanSequencerLength is a paid mutator transaction binding the contract method 0x03d9087d.
+//
+// Solidity: function testGetCurrentSequencerFailsIViewNumberGreaterThanSequencerLength() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TestGetCurrentSequencerFailsIViewNumberGreaterThanSequencerLength() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestGetCurrentSequencerFailsIViewNumberGreaterThanSequencerLength(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestGetCurrentSequencerFailsIViewNumberGreaterThanSequencerLength is a paid mutator transaction binding the contract method 0x03d9087d.
+//
+// Solidity: function testGetCurrentSequencerFailsIViewNumberGreaterThanSequencerLength() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactorSession) TestGetCurrentSequencerFailsIViewNumberGreaterThanSequencerLength() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestGetCurrentSequencerFailsIViewNumberGreaterThanSequencerLength(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestInsertFailsIfNotAuthorized is a paid mutator transaction binding the contract method 0x761c09dc.
+//
+// Solidity: function testInsertFailsIfNotAuthorized() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactor) TestInsertFailsIfNotAuthorized(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.contract.Transact(opts, "testInsertFailsIfNotAuthorized")
+}
+
+// TestInsertFailsIfNotAuthorized is a paid mutator transaction binding the contract method 0x761c09dc.
+//
+// Solidity: function testInsertFailsIfNotAuthorized() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TestInsertFailsIfNotAuthorized() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestInsertFailsIfNotAuthorized(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestInsertFailsIfNotAuthorized is a paid mutator transaction binding the contract method 0x761c09dc.
+//
+// Solidity: function testInsertFailsIfNotAuthorized() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactorSession) TestInsertFailsIfNotAuthorized() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestInsertFailsIfNotAuthorized(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestInsertSequencer is a paid mutator transaction binding the contract method 0xb35a510d.
+//
+// Solidity: function testInsertSequencer() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactor) TestInsertSequencer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.contract.Transact(opts, "testInsertSequencer")
+}
+
+// TestInsertSequencer is a paid mutator transaction binding the contract method 0xb35a510d.
+//
+// Solidity: function testInsertSequencer() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TestInsertSequencer() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestInsertSequencer(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestInsertSequencer is a paid mutator transaction binding the contract method 0xb35a510d.
+//
+// Solidity: function testInsertSequencer() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactorSession) TestInsertSequencer() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestInsertSequencer(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestInsertSequencerFailsIfSequencerAlreadyExists is a paid mutator transaction binding the contract method 0xd20a5f1e.
+//
+// Solidity: function testInsertSequencerFailsIfSequencerAlreadyExists() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactor) TestInsertSequencerFailsIfSequencerAlreadyExists(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.contract.Transact(opts, "testInsertSequencerFailsIfSequencerAlreadyExists")
+}
+
+// TestInsertSequencerFailsIfSequencerAlreadyExists is a paid mutator transaction binding the contract method 0xd20a5f1e.
+//
+// Solidity: function testInsertSequencerFailsIfSequencerAlreadyExists() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TestInsertSequencerFailsIfSequencerAlreadyExists() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestInsertSequencerFailsIfSequencerAlreadyExists(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestInsertSequencerFailsIfSequencerAlreadyExists is a paid mutator transaction binding the contract method 0xd20a5f1e.
+//
+// Solidity: function testInsertSequencerFailsIfSequencerAlreadyExists() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactorSession) TestInsertSequencerFailsIfSequencerAlreadyExists() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestInsertSequencerFailsIfSequencerAlreadyExists(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestRemoveSequencer is a paid mutator transaction binding the contract method 0x416114d2.
+//
+// Solidity: function testRemoveSequencer() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactor) TestRemoveSequencer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.contract.Transact(opts, "testRemoveSequencer")
+}
+
+// TestRemoveSequencer is a paid mutator transaction binding the contract method 0x416114d2.
+//
+// Solidity: function testRemoveSequencer() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TestRemoveSequencer() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestRemoveSequencer(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestRemoveSequencer is a paid mutator transaction binding the contract method 0x416114d2.
+//
+// Solidity: function testRemoveSequencer() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactorSession) TestRemoveSequencer() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestRemoveSequencer(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestRemoveSequencerFailsIfNotAuthorized is a paid mutator transaction binding the contract method 0xe4d9914d.
+//
+// Solidity: function testRemoveSequencerFailsIfNotAuthorized() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactor) TestRemoveSequencerFailsIfNotAuthorized(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.contract.Transact(opts, "testRemoveSequencerFailsIfNotAuthorized")
+}
+
+// TestRemoveSequencerFailsIfNotAuthorized is a paid mutator transaction binding the contract method 0xe4d9914d.
+//
+// Solidity: function testRemoveSequencerFailsIfNotAuthorized() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TestRemoveSequencerFailsIfNotAuthorized() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestRemoveSequencerFailsIfNotAuthorized(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestRemoveSequencerFailsIfNotAuthorized is a paid mutator transaction binding the contract method 0xe4d9914d.
+//
+// Solidity: function testRemoveSequencerFailsIfNotAuthorized() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactorSession) TestRemoveSequencerFailsIfNotAuthorized() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestRemoveSequencerFailsIfNotAuthorized(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestRemoveSequencerFailsIfSequencerDoesNotExist is a paid mutator transaction binding the contract method 0xa28cb685.
+//
+// Solidity: function testRemoveSequencerFailsIfSequencerDoesNotExist() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactor) TestRemoveSequencerFailsIfSequencerDoesNotExist(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.contract.Transact(opts, "testRemoveSequencerFailsIfSequencerDoesNotExist")
+}
+
+// TestRemoveSequencerFailsIfSequencerDoesNotExist is a paid mutator transaction binding the contract method 0xa28cb685.
+//
+// Solidity: function testRemoveSequencerFailsIfSequencerDoesNotExist() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestSession) TestRemoveSequencerFailsIfSequencerDoesNotExist() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestRemoveSequencerFailsIfSequencerDoesNotExist(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// TestRemoveSequencerFailsIfSequencerDoesNotExist is a paid mutator transaction binding the contract method 0xa28cb685.
+//
+// Solidity: function testRemoveSequencerFailsIfSequencerDoesNotExist() returns()
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestTransactorSession) TestRemoveSequencerFailsIfSequencerDoesNotExist() (*types.Transaction, error) {
+	return _EspressoRollupSequencerManagerTest.Contract.TestRemoveSequencerFailsIfSequencerDoesNotExist(&_EspressoRollupSequencerManagerTest.TransactOpts)
+}
+
+// EspressoRollupSequencerManagerTestSequencerAddedIterator is returned from FilterSequencerAdded and is used to iterate over the raw logs and unpacked data for SequencerAdded events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestSequencerAddedIterator struct {
+	Event *EspressoRollupSequencerManagerTestSequencerAdded // 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 *EspressoRollupSequencerManagerTestSequencerAddedIterator) 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(EspressoRollupSequencerManagerTestSequencerAdded)
+			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(EspressoRollupSequencerManagerTestSequencerAdded)
+		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 *EspressoRollupSequencerManagerTestSequencerAddedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestSequencerAddedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestSequencerAdded represents a SequencerAdded event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestSequencerAdded struct {
+	Sequencer common.Address
+	Nonce     *big.Int
+	Raw       types.Log // Blockchain specific contextual infos
+}
+
+// FilterSequencerAdded is a free log retrieval operation binding the contract event 0x4fd176ea5a84f3047cc893049bb44ef7418b01c9e07affb753a6847a9cfd6a66.
+//
+// Solidity: event SequencerAdded(address indexed sequencer, uint256 indexed nonce)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterSequencerAdded(opts *bind.FilterOpts, sequencer []common.Address, nonce []*big.Int) (*EspressoRollupSequencerManagerTestSequencerAddedIterator, error) {
+
+	var sequencerRule []interface{}
+	for _, sequencerItem := range sequencer {
+		sequencerRule = append(sequencerRule, sequencerItem)
+	}
+	var nonceRule []interface{}
+	for _, nonceItem := range nonce {
+		nonceRule = append(nonceRule, nonceItem)
+	}
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "SequencerAdded", sequencerRule, nonceRule)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestSequencerAddedIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "SequencerAdded", logs: logs, sub: sub}, nil
+}
+
+// WatchSequencerAdded is a free log subscription operation binding the contract event 0x4fd176ea5a84f3047cc893049bb44ef7418b01c9e07affb753a6847a9cfd6a66.
+//
+// Solidity: event SequencerAdded(address indexed sequencer, uint256 indexed nonce)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchSequencerAdded(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestSequencerAdded, sequencer []common.Address, nonce []*big.Int) (event.Subscription, error) {
+
+	var sequencerRule []interface{}
+	for _, sequencerItem := range sequencer {
+		sequencerRule = append(sequencerRule, sequencerItem)
+	}
+	var nonceRule []interface{}
+	for _, nonceItem := range nonce {
+		nonceRule = append(nonceRule, nonceItem)
+	}
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "SequencerAdded", sequencerRule, nonceRule)
+	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(EspressoRollupSequencerManagerTestSequencerAdded)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "SequencerAdded", 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
+}
+
+// ParseSequencerAdded is a log parse operation binding the contract event 0x4fd176ea5a84f3047cc893049bb44ef7418b01c9e07affb753a6847a9cfd6a66.
+//
+// Solidity: event SequencerAdded(address indexed sequencer, uint256 indexed nonce)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseSequencerAdded(log types.Log) (*EspressoRollupSequencerManagerTestSequencerAdded, error) {
+	event := new(EspressoRollupSequencerManagerTestSequencerAdded)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "SequencerAdded", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestSequencerRemovedIterator is returned from FilterSequencerRemoved and is used to iterate over the raw logs and unpacked data for SequencerRemoved events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestSequencerRemovedIterator struct {
+	Event *EspressoRollupSequencerManagerTestSequencerRemoved // 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 *EspressoRollupSequencerManagerTestSequencerRemovedIterator) 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(EspressoRollupSequencerManagerTestSequencerRemoved)
+			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(EspressoRollupSequencerManagerTestSequencerRemoved)
+		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 *EspressoRollupSequencerManagerTestSequencerRemovedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestSequencerRemovedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestSequencerRemoved represents a SequencerRemoved event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestSequencerRemoved struct {
+	Sequencer common.Address
+	Nonce     *big.Int
+	Raw       types.Log // Blockchain specific contextual infos
+}
+
+// FilterSequencerRemoved is a free log retrieval operation binding the contract event 0x211a133ec451de7013a054ec41eb8fa07df65089fda546cbaa7a0cffa08375bc.
+//
+// Solidity: event SequencerRemoved(address indexed sequencer, uint256 indexed nonce)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterSequencerRemoved(opts *bind.FilterOpts, sequencer []common.Address, nonce []*big.Int) (*EspressoRollupSequencerManagerTestSequencerRemovedIterator, error) {
+
+	var sequencerRule []interface{}
+	for _, sequencerItem := range sequencer {
+		sequencerRule = append(sequencerRule, sequencerItem)
+	}
+	var nonceRule []interface{}
+	for _, nonceItem := range nonce {
+		nonceRule = append(nonceRule, nonceItem)
+	}
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "SequencerRemoved", sequencerRule, nonceRule)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestSequencerRemovedIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "SequencerRemoved", logs: logs, sub: sub}, nil
+}
+
+// WatchSequencerRemoved is a free log subscription operation binding the contract event 0x211a133ec451de7013a054ec41eb8fa07df65089fda546cbaa7a0cffa08375bc.
+//
+// Solidity: event SequencerRemoved(address indexed sequencer, uint256 indexed nonce)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchSequencerRemoved(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestSequencerRemoved, sequencer []common.Address, nonce []*big.Int) (event.Subscription, error) {
+
+	var sequencerRule []interface{}
+	for _, sequencerItem := range sequencer {
+		sequencerRule = append(sequencerRule, sequencerItem)
+	}
+	var nonceRule []interface{}
+	for _, nonceItem := range nonce {
+		nonceRule = append(nonceRule, nonceItem)
+	}
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "SequencerRemoved", sequencerRule, nonceRule)
+	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(EspressoRollupSequencerManagerTestSequencerRemoved)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "SequencerRemoved", 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
+}
+
+// ParseSequencerRemoved is a log parse operation binding the contract event 0x211a133ec451de7013a054ec41eb8fa07df65089fda546cbaa7a0cffa08375bc.
+//
+// Solidity: event SequencerRemoved(address indexed sequencer, uint256 indexed nonce)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseSequencerRemoved(log types.Log) (*EspressoRollupSequencerManagerTestSequencerRemoved, error) {
+	event := new(EspressoRollupSequencerManagerTestSequencerRemoved)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "SequencerRemoved", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogIterator is returned from FilterLog and is used to iterate over the raw logs and unpacked data for Log events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogIterator struct {
+	Event *EspressoRollupSequencerManagerTestLog // 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 *EspressoRollupSequencerManagerTestLogIterator) 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(EspressoRollupSequencerManagerTestLog)
+			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(EspressoRollupSequencerManagerTestLog)
+		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 *EspressoRollupSequencerManagerTestLogIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLog represents a Log event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLog struct {
+	Arg0 string
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLog is a free log retrieval operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLog(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log", logs: logs, sub: sub}, nil
+}
+
+// WatchLog is a free log subscription operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLog(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLog) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log")
+	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(EspressoRollupSequencerManagerTestLog)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log", 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
+}
+
+// ParseLog is a log parse operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLog(log types.Log) (*EspressoRollupSequencerManagerTestLog, error) {
+	event := new(EspressoRollupSequencerManagerTestLog)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogAddressIterator is returned from FilterLogAddress and is used to iterate over the raw logs and unpacked data for LogAddress events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogAddressIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogAddress // 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 *EspressoRollupSequencerManagerTestLogAddressIterator) 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(EspressoRollupSequencerManagerTestLogAddress)
+			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(EspressoRollupSequencerManagerTestLogAddress)
+		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 *EspressoRollupSequencerManagerTestLogAddressIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogAddressIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogAddress represents a LogAddress event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogAddress struct {
+	Arg0 common.Address
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogAddress is a free log retrieval operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogAddress(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogAddressIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_address")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogAddressIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_address", logs: logs, sub: sub}, nil
+}
+
+// WatchLogAddress is a free log subscription operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogAddress(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogAddress) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_address")
+	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(EspressoRollupSequencerManagerTestLogAddress)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_address", 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
+}
+
+// ParseLogAddress is a log parse operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogAddress(log types.Log) (*EspressoRollupSequencerManagerTestLogAddress, error) {
+	event := new(EspressoRollupSequencerManagerTestLogAddress)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_address", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogArrayIterator is returned from FilterLogArray and is used to iterate over the raw logs and unpacked data for LogArray events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogArrayIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogArray // 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 *EspressoRollupSequencerManagerTestLogArrayIterator) 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(EspressoRollupSequencerManagerTestLogArray)
+			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(EspressoRollupSequencerManagerTestLogArray)
+		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 *EspressoRollupSequencerManagerTestLogArrayIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogArrayIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogArray represents a LogArray event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogArray struct {
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray is a free log retrieval operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogArray(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogArrayIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_array")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogArrayIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_array", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray is a free log subscription operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogArray(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogArray) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_array")
+	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(EspressoRollupSequencerManagerTestLogArray)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_array", 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
+}
+
+// ParseLogArray is a log parse operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogArray(log types.Log) (*EspressoRollupSequencerManagerTestLogArray, error) {
+	event := new(EspressoRollupSequencerManagerTestLogArray)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_array", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogArray0Iterator is returned from FilterLogArray0 and is used to iterate over the raw logs and unpacked data for LogArray0 events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogArray0Iterator struct {
+	Event *EspressoRollupSequencerManagerTestLogArray0 // 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 *EspressoRollupSequencerManagerTestLogArray0Iterator) 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(EspressoRollupSequencerManagerTestLogArray0)
+			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(EspressoRollupSequencerManagerTestLogArray0)
+		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 *EspressoRollupSequencerManagerTestLogArray0Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogArray0Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogArray0 represents a LogArray0 event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogArray0 struct {
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray0 is a free log retrieval operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogArray0(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogArray0Iterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_array0")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogArray0Iterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_array0", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray0 is a free log subscription operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogArray0(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogArray0) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_array0")
+	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(EspressoRollupSequencerManagerTestLogArray0)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_array0", 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
+}
+
+// ParseLogArray0 is a log parse operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogArray0(log types.Log) (*EspressoRollupSequencerManagerTestLogArray0, error) {
+	event := new(EspressoRollupSequencerManagerTestLogArray0)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_array0", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogArray1Iterator is returned from FilterLogArray1 and is used to iterate over the raw logs and unpacked data for LogArray1 events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogArray1Iterator struct {
+	Event *EspressoRollupSequencerManagerTestLogArray1 // 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 *EspressoRollupSequencerManagerTestLogArray1Iterator) 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(EspressoRollupSequencerManagerTestLogArray1)
+			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(EspressoRollupSequencerManagerTestLogArray1)
+		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 *EspressoRollupSequencerManagerTestLogArray1Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogArray1Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogArray1 represents a LogArray1 event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogArray1 struct {
+	Val []common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray1 is a free log retrieval operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogArray1(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogArray1Iterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_array1")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogArray1Iterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_array1", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray1 is a free log subscription operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogArray1(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogArray1) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_array1")
+	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(EspressoRollupSequencerManagerTestLogArray1)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_array1", 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
+}
+
+// ParseLogArray1 is a log parse operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogArray1(log types.Log) (*EspressoRollupSequencerManagerTestLogArray1, error) {
+	event := new(EspressoRollupSequencerManagerTestLogArray1)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_array1", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogBytesIterator is returned from FilterLogBytes and is used to iterate over the raw logs and unpacked data for LogBytes events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogBytesIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogBytes // 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 *EspressoRollupSequencerManagerTestLogBytesIterator) 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(EspressoRollupSequencerManagerTestLogBytes)
+			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(EspressoRollupSequencerManagerTestLogBytes)
+		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 *EspressoRollupSequencerManagerTestLogBytesIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogBytesIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogBytes represents a LogBytes event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogBytes struct {
+	Arg0 []byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogBytes is a free log retrieval operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogBytes(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogBytesIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_bytes")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogBytesIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_bytes", logs: logs, sub: sub}, nil
+}
+
+// WatchLogBytes is a free log subscription operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogBytes(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogBytes) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_bytes")
+	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(EspressoRollupSequencerManagerTestLogBytes)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_bytes", 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
+}
+
+// ParseLogBytes is a log parse operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogBytes(log types.Log) (*EspressoRollupSequencerManagerTestLogBytes, error) {
+	event := new(EspressoRollupSequencerManagerTestLogBytes)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_bytes", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogBytes32Iterator is returned from FilterLogBytes32 and is used to iterate over the raw logs and unpacked data for LogBytes32 events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogBytes32Iterator struct {
+	Event *EspressoRollupSequencerManagerTestLogBytes32 // 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 *EspressoRollupSequencerManagerTestLogBytes32Iterator) 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(EspressoRollupSequencerManagerTestLogBytes32)
+			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(EspressoRollupSequencerManagerTestLogBytes32)
+		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 *EspressoRollupSequencerManagerTestLogBytes32Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogBytes32Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogBytes32 represents a LogBytes32 event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogBytes32 struct {
+	Arg0 [32]byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogBytes32 is a free log retrieval operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogBytes32(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogBytes32Iterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_bytes32")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogBytes32Iterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_bytes32", logs: logs, sub: sub}, nil
+}
+
+// WatchLogBytes32 is a free log subscription operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogBytes32(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogBytes32) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_bytes32")
+	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(EspressoRollupSequencerManagerTestLogBytes32)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_bytes32", 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
+}
+
+// ParseLogBytes32 is a log parse operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogBytes32(log types.Log) (*EspressoRollupSequencerManagerTestLogBytes32, error) {
+	event := new(EspressoRollupSequencerManagerTestLogBytes32)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_bytes32", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogIntIterator is returned from FilterLogInt and is used to iterate over the raw logs and unpacked data for LogInt events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogIntIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogInt // 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 *EspressoRollupSequencerManagerTestLogIntIterator) 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(EspressoRollupSequencerManagerTestLogInt)
+			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(EspressoRollupSequencerManagerTestLogInt)
+		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 *EspressoRollupSequencerManagerTestLogIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogInt represents a LogInt event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogInt struct {
+	Arg0 *big.Int
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogInt is a free log retrieval operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogInt(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogIntIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_int")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogIntIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogInt is a free log subscription operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogInt(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogInt) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_int")
+	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(EspressoRollupSequencerManagerTestLogInt)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_int", 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
+}
+
+// ParseLogInt is a log parse operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogInt(log types.Log) (*EspressoRollupSequencerManagerTestLogInt, error) {
+	event := new(EspressoRollupSequencerManagerTestLogInt)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedAddressIterator is returned from FilterLogNamedAddress and is used to iterate over the raw logs and unpacked data for LogNamedAddress events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedAddressIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogNamedAddress // 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 *EspressoRollupSequencerManagerTestLogNamedAddressIterator) 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(EspressoRollupSequencerManagerTestLogNamedAddress)
+			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(EspressoRollupSequencerManagerTestLogNamedAddress)
+		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 *EspressoRollupSequencerManagerTestLogNamedAddressIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogNamedAddressIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedAddress represents a LogNamedAddress event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedAddress struct {
+	Key string
+	Val common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedAddress is a free log retrieval operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogNamedAddress(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogNamedAddressIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_named_address")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogNamedAddressIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_named_address", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedAddress is a free log subscription operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogNamedAddress(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogNamedAddress) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_named_address")
+	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(EspressoRollupSequencerManagerTestLogNamedAddress)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_address", 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
+}
+
+// ParseLogNamedAddress is a log parse operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogNamedAddress(log types.Log) (*EspressoRollupSequencerManagerTestLogNamedAddress, error) {
+	event := new(EspressoRollupSequencerManagerTestLogNamedAddress)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_address", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedArrayIterator is returned from FilterLogNamedArray and is used to iterate over the raw logs and unpacked data for LogNamedArray events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedArrayIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogNamedArray // 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 *EspressoRollupSequencerManagerTestLogNamedArrayIterator) 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(EspressoRollupSequencerManagerTestLogNamedArray)
+			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(EspressoRollupSequencerManagerTestLogNamedArray)
+		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 *EspressoRollupSequencerManagerTestLogNamedArrayIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogNamedArrayIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedArray represents a LogNamedArray event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedArray struct {
+	Key string
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray is a free log retrieval operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogNamedArray(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogNamedArrayIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_named_array")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogNamedArrayIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_named_array", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray is a free log subscription operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogNamedArray(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogNamedArray) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_named_array")
+	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(EspressoRollupSequencerManagerTestLogNamedArray)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_array", 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
+}
+
+// ParseLogNamedArray is a log parse operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogNamedArray(log types.Log) (*EspressoRollupSequencerManagerTestLogNamedArray, error) {
+	event := new(EspressoRollupSequencerManagerTestLogNamedArray)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_array", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedArray0Iterator is returned from FilterLogNamedArray0 and is used to iterate over the raw logs and unpacked data for LogNamedArray0 events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedArray0Iterator struct {
+	Event *EspressoRollupSequencerManagerTestLogNamedArray0 // 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 *EspressoRollupSequencerManagerTestLogNamedArray0Iterator) 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(EspressoRollupSequencerManagerTestLogNamedArray0)
+			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(EspressoRollupSequencerManagerTestLogNamedArray0)
+		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 *EspressoRollupSequencerManagerTestLogNamedArray0Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogNamedArray0Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedArray0 represents a LogNamedArray0 event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedArray0 struct {
+	Key string
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray0 is a free log retrieval operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogNamedArray0(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogNamedArray0Iterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_named_array0")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogNamedArray0Iterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_named_array0", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray0 is a free log subscription operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogNamedArray0(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogNamedArray0) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_named_array0")
+	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(EspressoRollupSequencerManagerTestLogNamedArray0)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_array0", 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
+}
+
+// ParseLogNamedArray0 is a log parse operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogNamedArray0(log types.Log) (*EspressoRollupSequencerManagerTestLogNamedArray0, error) {
+	event := new(EspressoRollupSequencerManagerTestLogNamedArray0)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_array0", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedArray1Iterator is returned from FilterLogNamedArray1 and is used to iterate over the raw logs and unpacked data for LogNamedArray1 events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedArray1Iterator struct {
+	Event *EspressoRollupSequencerManagerTestLogNamedArray1 // 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 *EspressoRollupSequencerManagerTestLogNamedArray1Iterator) 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(EspressoRollupSequencerManagerTestLogNamedArray1)
+			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(EspressoRollupSequencerManagerTestLogNamedArray1)
+		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 *EspressoRollupSequencerManagerTestLogNamedArray1Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogNamedArray1Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedArray1 represents a LogNamedArray1 event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedArray1 struct {
+	Key string
+	Val []common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray1 is a free log retrieval operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogNamedArray1(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogNamedArray1Iterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_named_array1")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogNamedArray1Iterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_named_array1", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray1 is a free log subscription operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogNamedArray1(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogNamedArray1) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_named_array1")
+	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(EspressoRollupSequencerManagerTestLogNamedArray1)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_array1", 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
+}
+
+// ParseLogNamedArray1 is a log parse operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogNamedArray1(log types.Log) (*EspressoRollupSequencerManagerTestLogNamedArray1, error) {
+	event := new(EspressoRollupSequencerManagerTestLogNamedArray1)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_array1", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedBytesIterator is returned from FilterLogNamedBytes and is used to iterate over the raw logs and unpacked data for LogNamedBytes events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedBytesIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogNamedBytes // 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 *EspressoRollupSequencerManagerTestLogNamedBytesIterator) 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(EspressoRollupSequencerManagerTestLogNamedBytes)
+			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(EspressoRollupSequencerManagerTestLogNamedBytes)
+		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 *EspressoRollupSequencerManagerTestLogNamedBytesIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogNamedBytesIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedBytes represents a LogNamedBytes event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedBytes struct {
+	Key string
+	Val []byte
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedBytes is a free log retrieval operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogNamedBytes(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogNamedBytesIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_named_bytes")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogNamedBytesIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_named_bytes", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedBytes is a free log subscription operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogNamedBytes(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogNamedBytes) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_named_bytes")
+	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(EspressoRollupSequencerManagerTestLogNamedBytes)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_bytes", 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
+}
+
+// ParseLogNamedBytes is a log parse operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogNamedBytes(log types.Log) (*EspressoRollupSequencerManagerTestLogNamedBytes, error) {
+	event := new(EspressoRollupSequencerManagerTestLogNamedBytes)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_bytes", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedBytes32Iterator is returned from FilterLogNamedBytes32 and is used to iterate over the raw logs and unpacked data for LogNamedBytes32 events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedBytes32Iterator struct {
+	Event *EspressoRollupSequencerManagerTestLogNamedBytes32 // 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 *EspressoRollupSequencerManagerTestLogNamedBytes32Iterator) 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(EspressoRollupSequencerManagerTestLogNamedBytes32)
+			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(EspressoRollupSequencerManagerTestLogNamedBytes32)
+		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 *EspressoRollupSequencerManagerTestLogNamedBytes32Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogNamedBytes32Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedBytes32 represents a LogNamedBytes32 event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedBytes32 struct {
+	Key string
+	Val [32]byte
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedBytes32 is a free log retrieval operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogNamedBytes32(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogNamedBytes32Iterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_named_bytes32")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogNamedBytes32Iterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_named_bytes32", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedBytes32 is a free log subscription operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogNamedBytes32(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogNamedBytes32) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_named_bytes32")
+	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(EspressoRollupSequencerManagerTestLogNamedBytes32)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_bytes32", 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
+}
+
+// ParseLogNamedBytes32 is a log parse operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogNamedBytes32(log types.Log) (*EspressoRollupSequencerManagerTestLogNamedBytes32, error) {
+	event := new(EspressoRollupSequencerManagerTestLogNamedBytes32)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_bytes32", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedDecimalIntIterator is returned from FilterLogNamedDecimalInt and is used to iterate over the raw logs and unpacked data for LogNamedDecimalInt events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedDecimalIntIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogNamedDecimalInt // 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 *EspressoRollupSequencerManagerTestLogNamedDecimalIntIterator) 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(EspressoRollupSequencerManagerTestLogNamedDecimalInt)
+			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(EspressoRollupSequencerManagerTestLogNamedDecimalInt)
+		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 *EspressoRollupSequencerManagerTestLogNamedDecimalIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogNamedDecimalIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedDecimalInt represents a LogNamedDecimalInt event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedDecimalInt struct {
+	Key      string
+	Val      *big.Int
+	Decimals *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedDecimalInt is a free log retrieval operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogNamedDecimalInt(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogNamedDecimalIntIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_named_decimal_int")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogNamedDecimalIntIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_named_decimal_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedDecimalInt is a free log subscription operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogNamedDecimalInt(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogNamedDecimalInt) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_named_decimal_int")
+	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(EspressoRollupSequencerManagerTestLogNamedDecimalInt)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_decimal_int", 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
+}
+
+// ParseLogNamedDecimalInt is a log parse operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogNamedDecimalInt(log types.Log) (*EspressoRollupSequencerManagerTestLogNamedDecimalInt, error) {
+	event := new(EspressoRollupSequencerManagerTestLogNamedDecimalInt)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedDecimalUintIterator is returned from FilterLogNamedDecimalUint and is used to iterate over the raw logs and unpacked data for LogNamedDecimalUint events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedDecimalUintIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogNamedDecimalUint // 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 *EspressoRollupSequencerManagerTestLogNamedDecimalUintIterator) 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(EspressoRollupSequencerManagerTestLogNamedDecimalUint)
+			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(EspressoRollupSequencerManagerTestLogNamedDecimalUint)
+		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 *EspressoRollupSequencerManagerTestLogNamedDecimalUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogNamedDecimalUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedDecimalUint represents a LogNamedDecimalUint event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedDecimalUint struct {
+	Key      string
+	Val      *big.Int
+	Decimals *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedDecimalUint is a free log retrieval operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogNamedDecimalUint(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogNamedDecimalUintIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_named_decimal_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogNamedDecimalUintIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_named_decimal_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedDecimalUint is a free log subscription operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogNamedDecimalUint(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogNamedDecimalUint) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_named_decimal_uint")
+	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(EspressoRollupSequencerManagerTestLogNamedDecimalUint)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_decimal_uint", 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
+}
+
+// ParseLogNamedDecimalUint is a log parse operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogNamedDecimalUint(log types.Log) (*EspressoRollupSequencerManagerTestLogNamedDecimalUint, error) {
+	event := new(EspressoRollupSequencerManagerTestLogNamedDecimalUint)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedIntIterator is returned from FilterLogNamedInt and is used to iterate over the raw logs and unpacked data for LogNamedInt events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedIntIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogNamedInt // 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 *EspressoRollupSequencerManagerTestLogNamedIntIterator) 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(EspressoRollupSequencerManagerTestLogNamedInt)
+			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(EspressoRollupSequencerManagerTestLogNamedInt)
+		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 *EspressoRollupSequencerManagerTestLogNamedIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogNamedIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedInt represents a LogNamedInt event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedInt struct {
+	Key string
+	Val *big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedInt is a free log retrieval operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogNamedInt(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogNamedIntIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_named_int")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogNamedIntIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_named_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedInt is a free log subscription operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogNamedInt(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogNamedInt) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_named_int")
+	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(EspressoRollupSequencerManagerTestLogNamedInt)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_int", 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
+}
+
+// ParseLogNamedInt is a log parse operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogNamedInt(log types.Log) (*EspressoRollupSequencerManagerTestLogNamedInt, error) {
+	event := new(EspressoRollupSequencerManagerTestLogNamedInt)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedStringIterator is returned from FilterLogNamedString and is used to iterate over the raw logs and unpacked data for LogNamedString events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedStringIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogNamedString // 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 *EspressoRollupSequencerManagerTestLogNamedStringIterator) 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(EspressoRollupSequencerManagerTestLogNamedString)
+			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(EspressoRollupSequencerManagerTestLogNamedString)
+		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 *EspressoRollupSequencerManagerTestLogNamedStringIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogNamedStringIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedString represents a LogNamedString event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedString struct {
+	Key string
+	Val string
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedString is a free log retrieval operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogNamedString(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogNamedStringIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_named_string")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogNamedStringIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_named_string", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedString is a free log subscription operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogNamedString(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogNamedString) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_named_string")
+	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(EspressoRollupSequencerManagerTestLogNamedString)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_string", 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
+}
+
+// ParseLogNamedString is a log parse operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogNamedString(log types.Log) (*EspressoRollupSequencerManagerTestLogNamedString, error) {
+	event := new(EspressoRollupSequencerManagerTestLogNamedString)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_string", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedUintIterator is returned from FilterLogNamedUint and is used to iterate over the raw logs and unpacked data for LogNamedUint events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedUintIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogNamedUint // 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 *EspressoRollupSequencerManagerTestLogNamedUintIterator) 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(EspressoRollupSequencerManagerTestLogNamedUint)
+			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(EspressoRollupSequencerManagerTestLogNamedUint)
+		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 *EspressoRollupSequencerManagerTestLogNamedUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogNamedUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogNamedUint represents a LogNamedUint event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogNamedUint struct {
+	Key string
+	Val *big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedUint is a free log retrieval operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogNamedUint(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogNamedUintIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_named_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogNamedUintIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_named_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedUint is a free log subscription operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogNamedUint(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogNamedUint) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_named_uint")
+	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(EspressoRollupSequencerManagerTestLogNamedUint)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_uint", 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
+}
+
+// ParseLogNamedUint is a log parse operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogNamedUint(log types.Log) (*EspressoRollupSequencerManagerTestLogNamedUint, error) {
+	event := new(EspressoRollupSequencerManagerTestLogNamedUint)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_named_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogStringIterator is returned from FilterLogString and is used to iterate over the raw logs and unpacked data for LogString events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogStringIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogString // 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 *EspressoRollupSequencerManagerTestLogStringIterator) 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(EspressoRollupSequencerManagerTestLogString)
+			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(EspressoRollupSequencerManagerTestLogString)
+		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 *EspressoRollupSequencerManagerTestLogStringIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogStringIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogString represents a LogString event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogString struct {
+	Arg0 string
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogString is a free log retrieval operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogString(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogStringIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_string")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogStringIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_string", logs: logs, sub: sub}, nil
+}
+
+// WatchLogString is a free log subscription operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogString(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogString) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_string")
+	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(EspressoRollupSequencerManagerTestLogString)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_string", 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
+}
+
+// ParseLogString is a log parse operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogString(log types.Log) (*EspressoRollupSequencerManagerTestLogString, error) {
+	event := new(EspressoRollupSequencerManagerTestLogString)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_string", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogUintIterator is returned from FilterLogUint and is used to iterate over the raw logs and unpacked data for LogUint events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogUintIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogUint // 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 *EspressoRollupSequencerManagerTestLogUintIterator) 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(EspressoRollupSequencerManagerTestLogUint)
+			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(EspressoRollupSequencerManagerTestLogUint)
+		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 *EspressoRollupSequencerManagerTestLogUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogUint represents a LogUint event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogUint struct {
+	Arg0 *big.Int
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogUint is a free log retrieval operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogUint(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogUintIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "log_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogUintIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "log_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogUint is a free log subscription operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogUint(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogUint) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "log_uint")
+	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(EspressoRollupSequencerManagerTestLogUint)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_uint", 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
+}
+
+// ParseLogUint is a log parse operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogUint(log types.Log) (*EspressoRollupSequencerManagerTestLogUint, error) {
+	event := new(EspressoRollupSequencerManagerTestLogUint)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "log_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoRollupSequencerManagerTestLogsIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for Logs events raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogsIterator struct {
+	Event *EspressoRollupSequencerManagerTestLogs // 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 *EspressoRollupSequencerManagerTestLogsIterator) 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(EspressoRollupSequencerManagerTestLogs)
+			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(EspressoRollupSequencerManagerTestLogs)
+		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 *EspressoRollupSequencerManagerTestLogsIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoRollupSequencerManagerTestLogsIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoRollupSequencerManagerTestLogs represents a Logs event raised by the EspressoRollupSequencerManagerTest contract.
+type EspressoRollupSequencerManagerTestLogs struct {
+	Arg0 []byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogs is a free log retrieval operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) FilterLogs(opts *bind.FilterOpts) (*EspressoRollupSequencerManagerTestLogsIterator, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.FilterLogs(opts, "logs")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoRollupSequencerManagerTestLogsIterator{contract: _EspressoRollupSequencerManagerTest.contract, event: "logs", logs: logs, sub: sub}, nil
+}
+
+// WatchLogs is a free log subscription operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) WatchLogs(opts *bind.WatchOpts, sink chan<- *EspressoRollupSequencerManagerTestLogs) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoRollupSequencerManagerTest.contract.WatchLogs(opts, "logs")
+	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(EspressoRollupSequencerManagerTestLogs)
+				if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "logs", 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
+}
+
+// ParseLogs is a log parse operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_EspressoRollupSequencerManagerTest *EspressoRollupSequencerManagerTestFilterer) ParseLogs(log types.Log) (*EspressoRollupSequencerManagerTestLogs, error) {
+	event := new(EspressoRollupSequencerManagerTestLogs)
+	if err := _EspressoRollupSequencerManagerTest.contract.UnpackLog(event, "logs", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierMetaData contains all meta data concerning the EspressoSGXTEEVerifier contract.
+var EspressoSGXTEEVerifierMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"_quoteVerifier\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"signers\",\"type\":\"address[]\"}],\"name\":\"deleteRegisteredSigners\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"rawEnclaveReport\",\"type\":\"bytes\"}],\"name\":\"parseEnclaveReport\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"bytes16\",\"name\":\"cpuSvn\",\"type\":\"bytes16\"},{\"internalType\":\"bytes4\",\"name\":\"miscSelect\",\"type\":\"bytes4\"},{\"internalType\":\"bytes28\",\"name\":\"reserved1\",\"type\":\"bytes28\"},{\"internalType\":\"bytes16\",\"name\":\"attributes\",\"type\":\"bytes16\"},{\"internalType\":\"bytes32\",\"name\":\"mrEnclave\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"reserved2\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"mrSigner\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"reserved3\",\"type\":\"bytes\"},{\"internalType\":\"uint16\",\"name\":\"isvProdId\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"isvSvn\",\"type\":\"uint16\"},{\"internalType\":\"bytes\",\"name\":\"reserved4\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"reportData\",\"type\":\"bytes\"}],\"internalType\":\"structEnclaveReport\",\"name\":\"enclaveReport\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"rawQuote\",\"type\":\"bytes\"}],\"name\":\"parseQuoteHeader\",\"outputs\":[{\"components\":[{\"internalType\":\"uint16\",\"name\":\"version\",\"type\":\"uint16\"},{\"internalType\":\"bytes2\",\"name\":\"attestationKeyType\",\"type\":\"bytes2\"},{\"internalType\":\"bytes4\",\"name\":\"teeType\",\"type\":\"bytes4\"},{\"internalType\":\"bytes2\",\"name\":\"qeSvn\",\"type\":\"bytes2\"},{\"internalType\":\"bytes2\",\"name\":\"pceSvn\",\"type\":\"bytes2\"},{\"internalType\":\"bytes16\",\"name\":\"qeVendorId\",\"type\":\"bytes16\"},{\"internalType\":\"bytes20\",\"name\":\"userData\",\"type\":\"bytes20\"}],\"internalType\":\"structHeader\",\"name\":\"header\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"quoteVerifier\",\"outputs\":[{\"internalType\":\"contractV3QuoteVerifier\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"attestation\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"registerSigner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"registeredEnclaveHash\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"registeredSigners\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"},{\"internalType\":\"bool\",\"name\":\"valid\",\"type\":\"bool\"}],\"name\":\"setEnclaveHash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"rawQuote\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"reportDataHash\",\"type\":\"bytes32\"}],\"name\":\"verify\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes16\",\"name\":\"cpuSvn\",\"type\":\"bytes16\"},{\"internalType\":\"bytes4\",\"name\":\"miscSelect\",\"type\":\"bytes4\"},{\"internalType\":\"bytes28\",\"name\":\"reserved1\",\"type\":\"bytes28\"},{\"internalType\":\"bytes16\",\"name\":\"attributes\",\"type\":\"bytes16\"},{\"internalType\":\"bytes32\",\"name\":\"mrEnclave\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"reserved2\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"mrSigner\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"reserved3\",\"type\":\"bytes\"},{\"internalType\":\"uint16\",\"name\":\"isvProdId\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"isvSvn\",\"type\":\"uint16\"},{\"internalType\":\"bytes\",\"name\":\"reserved4\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"reportData\",\"type\":\"bytes\"}],\"internalType\":\"structEnclaveReport\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"DeletedRegisteredSigner\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"valid\",\"type\":\"bool\"}],\"name\":\"EnclaveHashSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"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\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"}],\"name\":\"SignerRegistered\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FailedToParseEnclaveReport\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidDataLength\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidEnclaveHash\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidHeaderVersion\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidQuote\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidQuoteVerifierAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidReportDataHash\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignerAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReportDataTooShort\",\"type\":\"error\"}]",
+	Bin: "0x6080346100c957601f611a2038819003918201601f19168301916001600160401b038311848410176100cd5780849260409485528339810103126100c95780516020909101516001600160a01b038116908181036100c957610060336100e1565b81159081156100bf575b506100ad5760018060a01b031960025416176002555f52600360205260405f20600160ff1982541617905561009e336100e1565b6040516118f3908161012d8239f35b60405163486045cf60e11b8152600490fd5b90503b155f61006a565b5f80fd5b634e487b7160e01b5f52604160045260245ffd5b60018060a01b03199081600154166001555f5460018060a01b0380921680938216175f55167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e05f80a356fe60806040526004361015610011575f80fd5b5f3560e01c80630123d0c1146100f4578063384909fa146100ef5780636b406341146100ea578063715018a6146100e557806378df6dde146100e057806379ba5097146100db5780637ac17b51146100d65780638da5cb5b146100d157806393b5552e146100cc578063966989ee146100c7578063ba58e82a146100c2578063e30c3978146100bd578063e7370be0146100b85763f2fde38b146100b3575f80fd5b610934565b6108a2565b61087a565b610710565b6106e1565b61066d565b61063c565b6105f2565b6104d2565b61046a565b61031d565b6102c6565b61017d565b610140565b600435906001600160a01b038216820361010f57565b5f80fd5b35906001600160a01b038216820361010f57565b6001600160a01b03165f90815260046020526040902090565b3461010f57602036600319011261010f576001600160a01b036101616100f9565b165f526004602052602060ff60405f2054166040519015158152f35b3461010f575f36600319011261010f576002546040516001600160a01b039091168152602090f35b9181601f8401121561010f578235916001600160401b03831161010f576020838186019501011161010f57565b805180835260209291819084018484015e5f828201840152601f01601f1916010190565b80516001600160801b03191682526102c391906102af61027d6101806020848101516001600160e01b0319169086015260408481015163ffffffff1916908601526060848101516001600160801b031916908601526080840151608086015260a084015160a086015260c084015160c086015260e0840151908060e08701528501906101d2565b6101008381015161ffff16908501526101208381015161ffff16908501526101408084015190858303908601526101d2565b9161016080920151918184039101526101d2565b90565b3461010f57604036600319011261010f576004356001600160401b03811161010f576103056102fc6103199236906004016101a5565b60243591610b82565b6040519182916020835260208301906101f6565b0390f35b3461010f575f36600319011261010f57610335611760565b600180546001600160a01b03199081169091555f80549182168155906001600160a01b03165f8051602061189e8339815191528280a3005b634e487b7160e01b5f52604160045260245ffd5b604081019081106001600160401b0382111761039c57604052565b61036d565b608081019081106001600160401b0382111761039c57604052565b606081019081106001600160401b0382111761039c57604052565b601f909101601f19168101906001600160401b0382119082101761039c57604052565b6040519060e082016001600160401b0381118382101761039c57604052565b6001600160401b03811161039c57601f01601f191660200190565b92919261044082610419565b9161044e60405193846103d7565b82948184528183011161010f578281602093845f960137010152565b3461010f57602036600319011261010f576004356001600160401b03811161010f573660238201121561010f576104ae6104b3913690602481600401359101610434565b610d7a565b90610319604051928392151583526040602084015260408301906101f6565b3461010f575f36600319011261010f576001546001600160a01b0333818316036105245760018060a01b03198092166001555f549133908316175f553391165f8051602061189e8339815191525f80a3005b60405162461bcd60e51b815260206004820152602960248201527f4f776e61626c6532537465703a2063616c6c6572206973206e6f7420746865206044820152683732bb9037bbb732b960b91b6064820152608490fd5b805161ffff1682526020808201516001600160f01b0319908116918401919091526040808301516001600160e01b031916908401526060808301518216908401526080808301519091169083015260a0808201516001600160801b0319169083015260c0908101516001600160601b031916910152565b3461010f57602036600319011261010f576004356001600160401b03811161010f5761062d61062760e09236906004016101a5565b90610f3c565b61063a604051809261057b565bf35b3461010f575f36600319011261010f575f546040516001600160a01b039091168152602090f35b8015150361010f57565b3461010f57604036600319011261010f577f2282c24f65eac8254df1107716a961b677b872ed0e1d2a9f6bafc154441eb7fd60406004356024356106b081610663565b6106b8611760565b815f526003602052825f209015159060ff1981541660ff831617905582519182526020820152a1005b3461010f57602036600319011261010f576004355f526003602052602060ff60405f2054166040519015158152f35b3461010f57604036600319011261010f576001600160401b036004803582811161010f5761074190369083016101a5565b9260243590811161010f5761075990369084016101a5565b91909360148303610869579061078191610774368588610434565b6020815191012091610b82565b9260146101608501515110610858576107a96107a36107bb936107af93610acb565b90610f10565b60601c90565b6001600160a01b031690565b906001600160a01b0382161561084957506107e66107e26107db83610127565b5460ff1690565b1590565b6107ec57005b60807fcf848c482fcf6fe3067875f261b92c8f20a9756538ee17b8ef66ad0b7bae208c9261082961081c84610127565b805460ff19166001179055565b0151604080516001600160a01b03939093168352602083019190915290a1005b604051634501a91960e01b8152fd5b604051632912723560e11b81528390fd5b604051630dfe930960e41b81528490fd5b3461010f575f36600319011261010f576001546040516001600160a01b039091168152602090f35b3461010f5760208060031936011261010f576001600160401b0360043581811161010f573660238201121561010f57806004013591821161039c578160051b604051926108f260208301856103d7565b8352602460208401918301019136831161010f57602401905b82821061091d5761091b846110a3565b005b84809161092984610113565b81520191019061090b565b3461010f57602036600319011261010f5761094d6100f9565b610955611760565b60018060a01b03809116908160018060a01b031960015416176001555f54167f38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e227005f80a3005b6040519061018082016001600160401b0381118382101761039c576040526060610160835f81525f60208201525f60408201525f838201525f60808201525f60a08201525f60c08201528260e08201525f6101008201525f610120820152826101408201520152565b919060408382031261010f578251610a1a81610663565b602084015190936001600160401b03821161010f570181601f8201121561010f57805190610a4782610419565b92610a5560405194856103d7565b8284526020838301011161010f57815f9260208093018386015e8301015290565b91928091610a87846101009261057b565b8060e08501528301528061012093848401375f828201840152601f01601f1916010190565b6040513d5f823e3d90fd5b634e487b7160e01b5f52601160045260245ffd5b9060141161010f5790601490565b906101b01161010f576030019061018090565b9060021161010f5790600290565b9060041161010f5760020190600290565b9060081161010f5760040190600490565b90600a1161010f5760080190600290565b90600c1161010f57600a0190600290565b90601c1161010f57600c0190601090565b9060301161010f57601c0190601490565b602081519101519060208110610b74575090565b5f199060200360031b1b1690565b90610b8b61099a565b50610b968183610f3c565b600361ffff610ba7835161ffff1690565b1603610cd3575f82610be69285610bc86107af60025460018060a01b031690565b9160405195869485938493633c52544560e21b855260048501610a76565b03915afa908115610cce575f91610cab575b5015610c9957610c176104ae91610c1e93610c1161099a565b50610ad9565b3691610434565b919015610c8757610c416107e26107db60808501515f52600360205260405f2090565b610c7557610c5b610c5661016084015161114c565b610b60565b03610c635790565b6040516319ae741360e11b8152600490fd5b6040516322446a7f60e21b8152600490fd5b604051638538f3b560e01b8152600490fd5b604051630f86180360e41b8152600490fd5b610cc791503d805f833e610cbf81836103d7565b810190610a03565b505f610bf8565b610aac565b6040516398948a5760e01b8152600490fd5b80516020909101516001600160801b0319808216939290919060108110610d0b57505050565b60100360031b82901b16169150565b906020825192015163ffffffff60e01b908181169360048110610d3c57505050565b60040360031b82901b16169150565b906020825192015163ffffffff199081811693601c8110610d6b57505050565b601c0360031b82901b16169150565b610d8261099a565b90610180815103610ec25780610db3610da5610da0610eb7946111ea565b610ce5565b6001600160801b0319168452565b610dd8610dc7610dc28361125c565b610d1a565b6001600160e01b0319166020850152565b610dfa610dec610de7836112d1565b610d4b565b63ffffffff19166040850152565b610e1a610e09610da083611346565b6001600160801b0319166060850152565b610e26610c56826113bb565b6080840152610e37610c568261142c565b60a0840152610e48610c568261149d565b60c0840152610e568161150e565b60e0840152610e85610e79610e72610e6d84611584565b6117f0565b61ffff1690565b61ffff16610100850152565b610ea3610e97610e72610e6d846115fb565b61ffff16610120850152565b610eac81611672565b6101408401526116e9565b610160820152600191565b505f91565b6001600160f01b03199035818116939260028110610ee457505050565b60020360031b82901b16169150565b6001600160801b03199035818116939260108110610d0b57505050565b6001600160601b03199035818116939260148110610f2d57505050565b60140360031b82901b16169150565b604051909160e08201916001600160401b0383118184101761039c5760c05f916102c3946040528281528260208201528260408201528260608201528260808201528260a08201520152611092610f9c610e72610e6d610c178588610aec565b93611081610fb3610fad8584610afa565b90610ec7565b93611070610fe6610fd6610fcd610e6d610c178689610b0b565b63ffffffff1690565b60e01b6001600160e01b03191690565b61105f610ff6610fad8588610b1c565b9161104e6110276107a361100d610fad898c610b2d565b9761102161101b828d610b3e565b90610ef3565b9a610b4f565b9961103d6110336103fa565b61ffff909e168e52565b6001600160f01b03191660208d0152565b6001600160e01b03191660408b0152565b6001600160f01b0319166060890152565b6001600160f01b0319166080870152565b6001600160801b03191660a0850152565b6001600160601b03191660c0830152565b906110ac611760565b5f5b825181101561111f576001907f4872495ab7a697b6ed37286c6738fc94eaf291e5e4908abc1e2b479894f002dd6001600160a01b03806110ee8488611124565b51165f5260209060048252604090815f2060ff1981541690556111118589611124565b51169051908152a1016110ae565b509050565b80518210156111385760209160051b010190565b634e487b7160e01b5f52603260045260245ffd5b8051602090811161010f576040519161116483610381565b81835281830190823683378280910191925b808210156111b657508061119757505f19905b518251821691191617905290565b6111ab6111a66111b092611872565b61188e565b611880565b90611189565b909192835181528181018091116111e557928181018091116111e55791601f1981019081116111e55790611176565b610ab7565b805160101161010f576040519061120082610381565b601082526020908183019082368337826010910191925b8082101561122d57508061119757509192915050565b909192835181528181018091116111e557928181018091116111e55791601f1981019081116111e55790611217565b805160141161010f576040519061127282610381565b600482526020906020830190602036833760306004910191925b808210156112a257508061119757509192915050565b909192835181528181018091116111e557928181018091116111e55791601f1981019081116111e5579061128c565b805160301161010f57604051906112e782610381565b601c8252602090602083019060203683376034601c910191925b8082101561131757508061119757509192915050565b909192835181528181018091116111e557928181018091116111e55791601f1981019081116111e55790611301565b805160401161010f576040519061135c82610381565b601082526020906020830190602036833760506010910191925b8082101561138c57508061119757509192915050565b909192835181528181018091116111e557928181018091116111e55791601f1981019081116111e55790611376565b805160601161010f57604051906113d182610381565b6020908183528183019082368337606083910191925b808210156113fd57508061119757509192915050565b909192835181528181018091116111e557928181018091116111e55791601f1981019081116111e557906113e7565b805160801161010f576040519061144282610381565b6020908183528183019082368337608083910191925b8082101561146e57508061119757509192915050565b909192835181528181018091116111e557928181018091116111e55791601f1981019081116111e55790611458565b805160a01161010f57604051906114b382610381565b602090818352818301908236833760a083910191925b808210156114df57508061119757509192915050565b909192835181528181018091116111e557928181018091116111e55791601f1981019081116111e557906114c9565b80516101001161010f5760405190611525826103a1565b606082526020906020830190606036833760c06060910191925b8082101561155557508061119757509192915050565b909192835181528181018091116111e557928181018091116111e55791601f1981019081116111e5579061153f565b80516101021161010f576040519061159b82610381565b60028252602090602083019060203683376101206002910191925b808210156115cc57508061119757509192915050565b909192835181528181018091116111e557928181018091116111e55791601f1981019081116111e557906115b6565b80516101041161010f576040519061161282610381565b60028252602090602083019060203683376101226002910191925b8082101561164357508061119757509192915050565b909192835181528181018091116111e557928181018091116111e55791601f1981019081116111e5579061162d565b80516101401161010f5760405190611689826103bc565b603c825260209060208301906040368337610124603c910191925b808210156116ba57508061119757509192915050565b909192835181528181018091116111e557928181018091116111e55791601f1981019081116111e557906116a4565b80516101801161010f5760405190611700826103bc565b60408252602090602083019060403683376101606040910191925b8082101561173157508061119757509192915050565b909192835181528181018091116111e557928181018091116111e55791601f1981019081116111e5579061171b565b5f546001600160a01b0316330361177357565b606460405162461bcd60e51b815260206004820152602060248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152fd5b600181901b91906001600160ff1b038116036111e557565b818102929181159184041417156111e557565b603f81116111e55760100a90565b5f9190825b815184101561186d5760208483010151611825611819611814876117b7565b6117e2565b600f8360f81c166117cf565b9061182f866117b7565b90600182018092116111e557611847611850926117e2565b9060fc1c6117cf565b81018091116111e55781018091116111e5576001909301926117f5565b925050565b60200390602082116111e557565b5f198101919082116111e557565b601f81116111e5576101000a9056fe8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0a26469706673582212207222f01c8c01497cad7f13def5ff3127ed59b155a0c73ae544c04bf137f8e96864736f6c63430008190033",
+}
+
+// EspressoSGXTEEVerifierABI is the input ABI used to generate the binding from.
+// Deprecated: Use EspressoSGXTEEVerifierMetaData.ABI instead.
+var EspressoSGXTEEVerifierABI = EspressoSGXTEEVerifierMetaData.ABI
+
+// EspressoSGXTEEVerifierBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use EspressoSGXTEEVerifierMetaData.Bin instead.
+var EspressoSGXTEEVerifierBin = EspressoSGXTEEVerifierMetaData.Bin
+
+// DeployEspressoSGXTEEVerifier deploys a new Ethereum contract, binding an instance of EspressoSGXTEEVerifier to it.
+func DeployEspressoSGXTEEVerifier(auth *bind.TransactOpts, backend bind.ContractBackend, enclaveHash [32]byte, _quoteVerifier common.Address) (common.Address, *types.Transaction, *EspressoSGXTEEVerifier, error) {
+	parsed, err := EspressoSGXTEEVerifierMetaData.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(EspressoSGXTEEVerifierBin), backend, enclaveHash, _quoteVerifier)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &EspressoSGXTEEVerifier{EspressoSGXTEEVerifierCaller: EspressoSGXTEEVerifierCaller{contract: contract}, EspressoSGXTEEVerifierTransactor: EspressoSGXTEEVerifierTransactor{contract: contract}, EspressoSGXTEEVerifierFilterer: EspressoSGXTEEVerifierFilterer{contract: contract}}, nil
+}
+
+// EspressoSGXTEEVerifier is an auto generated Go binding around an Ethereum contract.
+type EspressoSGXTEEVerifier struct {
+	EspressoSGXTEEVerifierCaller     // Read-only binding to the contract
+	EspressoSGXTEEVerifierTransactor // Write-only binding to the contract
+	EspressoSGXTEEVerifierFilterer   // Log filterer for contract events
+}
+
+// EspressoSGXTEEVerifierCaller is an auto generated read-only Go binding around an Ethereum contract.
+type EspressoSGXTEEVerifierCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoSGXTEEVerifierTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type EspressoSGXTEEVerifierTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoSGXTEEVerifierFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type EspressoSGXTEEVerifierFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoSGXTEEVerifierSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type EspressoSGXTEEVerifierSession struct {
+	Contract     *EspressoSGXTEEVerifier // 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
+}
+
+// EspressoSGXTEEVerifierCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type EspressoSGXTEEVerifierCallerSession struct {
+	Contract *EspressoSGXTEEVerifierCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts                 // Call options to use throughout this session
+}
+
+// EspressoSGXTEEVerifierTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type EspressoSGXTEEVerifierTransactorSession struct {
+	Contract     *EspressoSGXTEEVerifierTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts                 // Transaction auth options to use throughout this session
+}
+
+// EspressoSGXTEEVerifierRaw is an auto generated low-level Go binding around an Ethereum contract.
+type EspressoSGXTEEVerifierRaw struct {
+	Contract *EspressoSGXTEEVerifier // Generic contract binding to access the raw methods on
+}
+
+// EspressoSGXTEEVerifierCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type EspressoSGXTEEVerifierCallerRaw struct {
+	Contract *EspressoSGXTEEVerifierCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// EspressoSGXTEEVerifierTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type EspressoSGXTEEVerifierTransactorRaw struct {
+	Contract *EspressoSGXTEEVerifierTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewEspressoSGXTEEVerifier creates a new instance of EspressoSGXTEEVerifier, bound to a specific deployed contract.
+func NewEspressoSGXTEEVerifier(address common.Address, backend bind.ContractBackend) (*EspressoSGXTEEVerifier, error) {
+	contract, err := bindEspressoSGXTEEVerifier(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifier{EspressoSGXTEEVerifierCaller: EspressoSGXTEEVerifierCaller{contract: contract}, EspressoSGXTEEVerifierTransactor: EspressoSGXTEEVerifierTransactor{contract: contract}, EspressoSGXTEEVerifierFilterer: EspressoSGXTEEVerifierFilterer{contract: contract}}, nil
+}
+
+// NewEspressoSGXTEEVerifierCaller creates a new read-only instance of EspressoSGXTEEVerifier, bound to a specific deployed contract.
+func NewEspressoSGXTEEVerifierCaller(address common.Address, caller bind.ContractCaller) (*EspressoSGXTEEVerifierCaller, error) {
+	contract, err := bindEspressoSGXTEEVerifier(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierCaller{contract: contract}, nil
+}
+
+// NewEspressoSGXTEEVerifierTransactor creates a new write-only instance of EspressoSGXTEEVerifier, bound to a specific deployed contract.
+func NewEspressoSGXTEEVerifierTransactor(address common.Address, transactor bind.ContractTransactor) (*EspressoSGXTEEVerifierTransactor, error) {
+	contract, err := bindEspressoSGXTEEVerifier(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTransactor{contract: contract}, nil
+}
+
+// NewEspressoSGXTEEVerifierFilterer creates a new log filterer instance of EspressoSGXTEEVerifier, bound to a specific deployed contract.
+func NewEspressoSGXTEEVerifierFilterer(address common.Address, filterer bind.ContractFilterer) (*EspressoSGXTEEVerifierFilterer, error) {
+	contract, err := bindEspressoSGXTEEVerifier(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierFilterer{contract: contract}, nil
+}
+
+// bindEspressoSGXTEEVerifier binds a generic wrapper to an already deployed contract.
+func bindEspressoSGXTEEVerifier(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := EspressoSGXTEEVerifierMetaData.GetAbi()
+	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 (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoSGXTEEVerifier.Contract.EspressoSGXTEEVerifierCaller.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 (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.EspressoSGXTEEVerifierTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.EspressoSGXTEEVerifierTransactor.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 (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoSGXTEEVerifier.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 (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.contract.Transact(opts, method, params...)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifier.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 (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) Owner() (common.Address, error) {
+	return _EspressoSGXTEEVerifier.Contract.Owner(&_EspressoSGXTEEVerifier.CallOpts)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCallerSession) Owner() (common.Address, error) {
+	return _EspressoSGXTEEVerifier.Contract.Owner(&_EspressoSGXTEEVerifier.CallOpts)
+}
+
+// ParseEnclaveReport is a free data retrieval call binding the contract method 0x78df6dde.
+//
+// Solidity: function parseEnclaveReport(bytes rawEnclaveReport) pure returns(bool success, (bytes16,bytes4,bytes28,bytes16,bytes32,bytes32,bytes32,bytes,uint16,uint16,bytes,bytes) enclaveReport)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCaller) ParseEnclaveReport(opts *bind.CallOpts, rawEnclaveReport []byte) (struct {
+	Success       bool
+	EnclaveReport EnclaveReport
+}, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifier.contract.Call(opts, &out, "parseEnclaveReport", rawEnclaveReport)
+
+	outstruct := new(struct {
+		Success       bool
+		EnclaveReport EnclaveReport
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.Success = *abi.ConvertType(out[0], new(bool)).(*bool)
+	outstruct.EnclaveReport = *abi.ConvertType(out[1], new(EnclaveReport)).(*EnclaveReport)
+
+	return *outstruct, err
+
+}
+
+// ParseEnclaveReport is a free data retrieval call binding the contract method 0x78df6dde.
+//
+// Solidity: function parseEnclaveReport(bytes rawEnclaveReport) pure returns(bool success, (bytes16,bytes4,bytes28,bytes16,bytes32,bytes32,bytes32,bytes,uint16,uint16,bytes,bytes) enclaveReport)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) ParseEnclaveReport(rawEnclaveReport []byte) (struct {
+	Success       bool
+	EnclaveReport EnclaveReport
+}, error) {
+	return _EspressoSGXTEEVerifier.Contract.ParseEnclaveReport(&_EspressoSGXTEEVerifier.CallOpts, rawEnclaveReport)
+}
+
+// ParseEnclaveReport is a free data retrieval call binding the contract method 0x78df6dde.
+//
+// Solidity: function parseEnclaveReport(bytes rawEnclaveReport) pure returns(bool success, (bytes16,bytes4,bytes28,bytes16,bytes32,bytes32,bytes32,bytes,uint16,uint16,bytes,bytes) enclaveReport)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCallerSession) ParseEnclaveReport(rawEnclaveReport []byte) (struct {
+	Success       bool
+	EnclaveReport EnclaveReport
+}, error) {
+	return _EspressoSGXTEEVerifier.Contract.ParseEnclaveReport(&_EspressoSGXTEEVerifier.CallOpts, rawEnclaveReport)
+}
+
+// ParseQuoteHeader is a free data retrieval call binding the contract method 0x7ac17b51.
+//
+// Solidity: function parseQuoteHeader(bytes rawQuote) pure returns((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) header)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCaller) ParseQuoteHeader(opts *bind.CallOpts, rawQuote []byte) (Header, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifier.contract.Call(opts, &out, "parseQuoteHeader", rawQuote)
+
+	if err != nil {
+		return *new(Header), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(Header)).(*Header)
+
+	return out0, err
+
+}
+
+// ParseQuoteHeader is a free data retrieval call binding the contract method 0x7ac17b51.
+//
+// Solidity: function parseQuoteHeader(bytes rawQuote) pure returns((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) header)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) ParseQuoteHeader(rawQuote []byte) (Header, error) {
+	return _EspressoSGXTEEVerifier.Contract.ParseQuoteHeader(&_EspressoSGXTEEVerifier.CallOpts, rawQuote)
+}
+
+// ParseQuoteHeader is a free data retrieval call binding the contract method 0x7ac17b51.
+//
+// Solidity: function parseQuoteHeader(bytes rawQuote) pure returns((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) header)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCallerSession) ParseQuoteHeader(rawQuote []byte) (Header, error) {
+	return _EspressoSGXTEEVerifier.Contract.ParseQuoteHeader(&_EspressoSGXTEEVerifier.CallOpts, rawQuote)
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCaller) PendingOwner(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifier.contract.Call(opts, &out, "pendingOwner")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) PendingOwner() (common.Address, error) {
+	return _EspressoSGXTEEVerifier.Contract.PendingOwner(&_EspressoSGXTEEVerifier.CallOpts)
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCallerSession) PendingOwner() (common.Address, error) {
+	return _EspressoSGXTEEVerifier.Contract.PendingOwner(&_EspressoSGXTEEVerifier.CallOpts)
+}
+
+// QuoteVerifier is a free data retrieval call binding the contract method 0x384909fa.
+//
+// Solidity: function quoteVerifier() view returns(address)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCaller) QuoteVerifier(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifier.contract.Call(opts, &out, "quoteVerifier")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// QuoteVerifier is a free data retrieval call binding the contract method 0x384909fa.
+//
+// Solidity: function quoteVerifier() view returns(address)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) QuoteVerifier() (common.Address, error) {
+	return _EspressoSGXTEEVerifier.Contract.QuoteVerifier(&_EspressoSGXTEEVerifier.CallOpts)
+}
+
+// QuoteVerifier is a free data retrieval call binding the contract method 0x384909fa.
+//
+// Solidity: function quoteVerifier() view returns(address)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCallerSession) QuoteVerifier() (common.Address, error) {
+	return _EspressoSGXTEEVerifier.Contract.QuoteVerifier(&_EspressoSGXTEEVerifier.CallOpts)
+}
+
+// RegisteredEnclaveHash is a free data retrieval call binding the contract method 0x966989ee.
+//
+// Solidity: function registeredEnclaveHash(bytes32 ) view returns(bool)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCaller) RegisteredEnclaveHash(opts *bind.CallOpts, arg0 [32]byte) (bool, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifier.contract.Call(opts, &out, "registeredEnclaveHash", arg0)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredEnclaveHash is a free data retrieval call binding the contract method 0x966989ee.
+//
+// Solidity: function registeredEnclaveHash(bytes32 ) view returns(bool)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) RegisteredEnclaveHash(arg0 [32]byte) (bool, error) {
+	return _EspressoSGXTEEVerifier.Contract.RegisteredEnclaveHash(&_EspressoSGXTEEVerifier.CallOpts, arg0)
+}
+
+// RegisteredEnclaveHash is a free data retrieval call binding the contract method 0x966989ee.
+//
+// Solidity: function registeredEnclaveHash(bytes32 ) view returns(bool)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCallerSession) RegisteredEnclaveHash(arg0 [32]byte) (bool, error) {
+	return _EspressoSGXTEEVerifier.Contract.RegisteredEnclaveHash(&_EspressoSGXTEEVerifier.CallOpts, arg0)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0x0123d0c1.
+//
+// Solidity: function registeredSigners(address ) view returns(bool)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCaller) RegisteredSigners(opts *bind.CallOpts, arg0 common.Address) (bool, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifier.contract.Call(opts, &out, "registeredSigners", arg0)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0x0123d0c1.
+//
+// Solidity: function registeredSigners(address ) view returns(bool)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) RegisteredSigners(arg0 common.Address) (bool, error) {
+	return _EspressoSGXTEEVerifier.Contract.RegisteredSigners(&_EspressoSGXTEEVerifier.CallOpts, arg0)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0x0123d0c1.
+//
+// Solidity: function registeredSigners(address ) view returns(bool)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCallerSession) RegisteredSigners(arg0 common.Address) (bool, error) {
+	return _EspressoSGXTEEVerifier.Contract.RegisteredSigners(&_EspressoSGXTEEVerifier.CallOpts, arg0)
+}
+
+// Verify is a free data retrieval call binding the contract method 0x6b406341.
+//
+// Solidity: function verify(bytes rawQuote, bytes32 reportDataHash) view returns((bytes16,bytes4,bytes28,bytes16,bytes32,bytes32,bytes32,bytes,uint16,uint16,bytes,bytes))
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCaller) Verify(opts *bind.CallOpts, rawQuote []byte, reportDataHash [32]byte) (EnclaveReport, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifier.contract.Call(opts, &out, "verify", rawQuote, reportDataHash)
+
+	if err != nil {
+		return *new(EnclaveReport), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(EnclaveReport)).(*EnclaveReport)
+
+	return out0, err
+
+}
+
+// Verify is a free data retrieval call binding the contract method 0x6b406341.
+//
+// Solidity: function verify(bytes rawQuote, bytes32 reportDataHash) view returns((bytes16,bytes4,bytes28,bytes16,bytes32,bytes32,bytes32,bytes,uint16,uint16,bytes,bytes))
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) Verify(rawQuote []byte, reportDataHash [32]byte) (EnclaveReport, error) {
+	return _EspressoSGXTEEVerifier.Contract.Verify(&_EspressoSGXTEEVerifier.CallOpts, rawQuote, reportDataHash)
+}
+
+// Verify is a free data retrieval call binding the contract method 0x6b406341.
+//
+// Solidity: function verify(bytes rawQuote, bytes32 reportDataHash) view returns((bytes16,bytes4,bytes28,bytes16,bytes32,bytes32,bytes32,bytes,uint16,uint16,bytes,bytes))
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierCallerSession) Verify(rawQuote []byte, reportDataHash [32]byte) (EnclaveReport, error) {
+	return _EspressoSGXTEEVerifier.Contract.Verify(&_EspressoSGXTEEVerifier.CallOpts, rawQuote, reportDataHash)
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactor) AcceptOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.contract.Transact(opts, "acceptOwnership")
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) AcceptOwnership() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.AcceptOwnership(&_EspressoSGXTEEVerifier.TransactOpts)
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactorSession) AcceptOwnership() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.AcceptOwnership(&_EspressoSGXTEEVerifier.TransactOpts)
+}
+
+// DeleteRegisteredSigners is a paid mutator transaction binding the contract method 0xe7370be0.
+//
+// Solidity: function deleteRegisteredSigners(address[] signers) returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactor) DeleteRegisteredSigners(opts *bind.TransactOpts, signers []common.Address) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.contract.Transact(opts, "deleteRegisteredSigners", signers)
+}
+
+// DeleteRegisteredSigners is a paid mutator transaction binding the contract method 0xe7370be0.
+//
+// Solidity: function deleteRegisteredSigners(address[] signers) returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) DeleteRegisteredSigners(signers []common.Address) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.DeleteRegisteredSigners(&_EspressoSGXTEEVerifier.TransactOpts, signers)
+}
+
+// DeleteRegisteredSigners is a paid mutator transaction binding the contract method 0xe7370be0.
+//
+// Solidity: function deleteRegisteredSigners(address[] signers) returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactorSession) DeleteRegisteredSigners(signers []common.Address) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.DeleteRegisteredSigners(&_EspressoSGXTEEVerifier.TransactOpts, signers)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0xba58e82a.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data) returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactor) RegisterSigner(opts *bind.TransactOpts, attestation []byte, data []byte) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.contract.Transact(opts, "registerSigner", attestation, data)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0xba58e82a.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data) returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) RegisterSigner(attestation []byte, data []byte) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.RegisterSigner(&_EspressoSGXTEEVerifier.TransactOpts, attestation, data)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0xba58e82a.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data) returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactorSession) RegisterSigner(attestation []byte, data []byte) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.RegisterSigner(&_EspressoSGXTEEVerifier.TransactOpts, attestation, data)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.contract.Transact(opts, "renounceOwnership")
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) RenounceOwnership() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.RenounceOwnership(&_EspressoSGXTEEVerifier.TransactOpts)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactorSession) RenounceOwnership() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.RenounceOwnership(&_EspressoSGXTEEVerifier.TransactOpts)
+}
+
+// SetEnclaveHash is a paid mutator transaction binding the contract method 0x93b5552e.
+//
+// Solidity: function setEnclaveHash(bytes32 enclaveHash, bool valid) returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactor) SetEnclaveHash(opts *bind.TransactOpts, enclaveHash [32]byte, valid bool) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.contract.Transact(opts, "setEnclaveHash", enclaveHash, valid)
+}
+
+// SetEnclaveHash is a paid mutator transaction binding the contract method 0x93b5552e.
+//
+// Solidity: function setEnclaveHash(bytes32 enclaveHash, bool valid) returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) SetEnclaveHash(enclaveHash [32]byte, valid bool) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.SetEnclaveHash(&_EspressoSGXTEEVerifier.TransactOpts, enclaveHash, valid)
+}
+
+// SetEnclaveHash is a paid mutator transaction binding the contract method 0x93b5552e.
+//
+// Solidity: function setEnclaveHash(bytes32 enclaveHash, bool valid) returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactorSession) SetEnclaveHash(enclaveHash [32]byte, valid bool) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.SetEnclaveHash(&_EspressoSGXTEEVerifier.TransactOpts, enclaveHash, valid)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.contract.Transact(opts, "transferOwnership", newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.TransferOwnership(&_EspressoSGXTEEVerifier.TransactOpts, newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifier.Contract.TransferOwnership(&_EspressoSGXTEEVerifier.TransactOpts, newOwner)
+}
+
+// EspressoSGXTEEVerifierDeletedRegisteredSignerIterator is returned from FilterDeletedRegisteredSigner and is used to iterate over the raw logs and unpacked data for DeletedRegisteredSigner events raised by the EspressoSGXTEEVerifier contract.
+type EspressoSGXTEEVerifierDeletedRegisteredSignerIterator struct {
+	Event *EspressoSGXTEEVerifierDeletedRegisteredSigner // 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 *EspressoSGXTEEVerifierDeletedRegisteredSignerIterator) 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(EspressoSGXTEEVerifierDeletedRegisteredSigner)
+			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(EspressoSGXTEEVerifierDeletedRegisteredSigner)
+		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 *EspressoSGXTEEVerifierDeletedRegisteredSignerIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierDeletedRegisteredSignerIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierDeletedRegisteredSigner represents a DeletedRegisteredSigner event raised by the EspressoSGXTEEVerifier contract.
+type EspressoSGXTEEVerifierDeletedRegisteredSigner struct {
+	Signer common.Address
+	Raw    types.Log // Blockchain specific contextual infos
+}
+
+// FilterDeletedRegisteredSigner is a free log retrieval operation binding the contract event 0x4872495ab7a697b6ed37286c6738fc94eaf291e5e4908abc1e2b479894f002dd.
+//
+// Solidity: event DeletedRegisteredSigner(address signer)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) FilterDeletedRegisteredSigner(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierDeletedRegisteredSignerIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifier.contract.FilterLogs(opts, "DeletedRegisteredSigner")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierDeletedRegisteredSignerIterator{contract: _EspressoSGXTEEVerifier.contract, event: "DeletedRegisteredSigner", logs: logs, sub: sub}, nil
+}
+
+// WatchDeletedRegisteredSigner is a free log subscription operation binding the contract event 0x4872495ab7a697b6ed37286c6738fc94eaf291e5e4908abc1e2b479894f002dd.
+//
+// Solidity: event DeletedRegisteredSigner(address signer)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) WatchDeletedRegisteredSigner(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierDeletedRegisteredSigner) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifier.contract.WatchLogs(opts, "DeletedRegisteredSigner")
+	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(EspressoSGXTEEVerifierDeletedRegisteredSigner)
+				if err := _EspressoSGXTEEVerifier.contract.UnpackLog(event, "DeletedRegisteredSigner", 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
+}
+
+// ParseDeletedRegisteredSigner is a log parse operation binding the contract event 0x4872495ab7a697b6ed37286c6738fc94eaf291e5e4908abc1e2b479894f002dd.
+//
+// Solidity: event DeletedRegisteredSigner(address signer)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) ParseDeletedRegisteredSigner(log types.Log) (*EspressoSGXTEEVerifierDeletedRegisteredSigner, error) {
+	event := new(EspressoSGXTEEVerifierDeletedRegisteredSigner)
+	if err := _EspressoSGXTEEVerifier.contract.UnpackLog(event, "DeletedRegisteredSigner", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierEnclaveHashSetIterator is returned from FilterEnclaveHashSet and is used to iterate over the raw logs and unpacked data for EnclaveHashSet events raised by the EspressoSGXTEEVerifier contract.
+type EspressoSGXTEEVerifierEnclaveHashSetIterator struct {
+	Event *EspressoSGXTEEVerifierEnclaveHashSet // 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 *EspressoSGXTEEVerifierEnclaveHashSetIterator) 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(EspressoSGXTEEVerifierEnclaveHashSet)
+			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(EspressoSGXTEEVerifierEnclaveHashSet)
+		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 *EspressoSGXTEEVerifierEnclaveHashSetIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierEnclaveHashSetIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierEnclaveHashSet represents a EnclaveHashSet event raised by the EspressoSGXTEEVerifier contract.
+type EspressoSGXTEEVerifierEnclaveHashSet struct {
+	EnclaveHash [32]byte
+	Valid       bool
+	Raw         types.Log // Blockchain specific contextual infos
+}
+
+// FilterEnclaveHashSet is a free log retrieval operation binding the contract event 0x2282c24f65eac8254df1107716a961b677b872ed0e1d2a9f6bafc154441eb7fd.
+//
+// Solidity: event EnclaveHashSet(bytes32 enclaveHash, bool valid)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) FilterEnclaveHashSet(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierEnclaveHashSetIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifier.contract.FilterLogs(opts, "EnclaveHashSet")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierEnclaveHashSetIterator{contract: _EspressoSGXTEEVerifier.contract, event: "EnclaveHashSet", logs: logs, sub: sub}, nil
+}
+
+// WatchEnclaveHashSet is a free log subscription operation binding the contract event 0x2282c24f65eac8254df1107716a961b677b872ed0e1d2a9f6bafc154441eb7fd.
+//
+// Solidity: event EnclaveHashSet(bytes32 enclaveHash, bool valid)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) WatchEnclaveHashSet(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierEnclaveHashSet) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifier.contract.WatchLogs(opts, "EnclaveHashSet")
+	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(EspressoSGXTEEVerifierEnclaveHashSet)
+				if err := _EspressoSGXTEEVerifier.contract.UnpackLog(event, "EnclaveHashSet", 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
+}
+
+// ParseEnclaveHashSet is a log parse operation binding the contract event 0x2282c24f65eac8254df1107716a961b677b872ed0e1d2a9f6bafc154441eb7fd.
+//
+// Solidity: event EnclaveHashSet(bytes32 enclaveHash, bool valid)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) ParseEnclaveHashSet(log types.Log) (*EspressoSGXTEEVerifierEnclaveHashSet, error) {
+	event := new(EspressoSGXTEEVerifierEnclaveHashSet)
+	if err := _EspressoSGXTEEVerifier.contract.UnpackLog(event, "EnclaveHashSet", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierOwnershipTransferStartedIterator is returned from FilterOwnershipTransferStarted and is used to iterate over the raw logs and unpacked data for OwnershipTransferStarted events raised by the EspressoSGXTEEVerifier contract.
+type EspressoSGXTEEVerifierOwnershipTransferStartedIterator struct {
+	Event *EspressoSGXTEEVerifierOwnershipTransferStarted // 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 *EspressoSGXTEEVerifierOwnershipTransferStartedIterator) 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(EspressoSGXTEEVerifierOwnershipTransferStarted)
+			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(EspressoSGXTEEVerifierOwnershipTransferStarted)
+		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 *EspressoSGXTEEVerifierOwnershipTransferStartedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierOwnershipTransferStartedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierOwnershipTransferStarted represents a OwnershipTransferStarted event raised by the EspressoSGXTEEVerifier contract.
+type EspressoSGXTEEVerifierOwnershipTransferStarted struct {
+	PreviousOwner common.Address
+	NewOwner      common.Address
+	Raw           types.Log // Blockchain specific contextual infos
+}
+
+// FilterOwnershipTransferStarted is a free log retrieval operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) FilterOwnershipTransferStarted(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*EspressoSGXTEEVerifierOwnershipTransferStartedIterator, 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 := _EspressoSGXTEEVerifier.contract.FilterLogs(opts, "OwnershipTransferStarted", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierOwnershipTransferStartedIterator{contract: _EspressoSGXTEEVerifier.contract, event: "OwnershipTransferStarted", logs: logs, sub: sub}, nil
+}
+
+// WatchOwnershipTransferStarted is a free log subscription operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) WatchOwnershipTransferStarted(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierOwnershipTransferStarted, 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 := _EspressoSGXTEEVerifier.contract.WatchLogs(opts, "OwnershipTransferStarted", 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(EspressoSGXTEEVerifierOwnershipTransferStarted)
+				if err := _EspressoSGXTEEVerifier.contract.UnpackLog(event, "OwnershipTransferStarted", 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
+}
+
+// ParseOwnershipTransferStarted is a log parse operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) ParseOwnershipTransferStarted(log types.Log) (*EspressoSGXTEEVerifierOwnershipTransferStarted, error) {
+	event := new(EspressoSGXTEEVerifierOwnershipTransferStarted)
+	if err := _EspressoSGXTEEVerifier.contract.UnpackLog(event, "OwnershipTransferStarted", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the EspressoSGXTEEVerifier contract.
+type EspressoSGXTEEVerifierOwnershipTransferredIterator struct {
+	Event *EspressoSGXTEEVerifierOwnershipTransferred // 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 *EspressoSGXTEEVerifierOwnershipTransferredIterator) 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(EspressoSGXTEEVerifierOwnershipTransferred)
+			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(EspressoSGXTEEVerifierOwnershipTransferred)
+		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 *EspressoSGXTEEVerifierOwnershipTransferredIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierOwnershipTransferredIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierOwnershipTransferred represents a OwnershipTransferred event raised by the EspressoSGXTEEVerifier contract.
+type EspressoSGXTEEVerifierOwnershipTransferred 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 (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*EspressoSGXTEEVerifierOwnershipTransferredIterator, 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 := _EspressoSGXTEEVerifier.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierOwnershipTransferredIterator{contract: _EspressoSGXTEEVerifier.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 (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierOwnershipTransferred, 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 := _EspressoSGXTEEVerifier.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(EspressoSGXTEEVerifierOwnershipTransferred)
+				if err := _EspressoSGXTEEVerifier.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 (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) ParseOwnershipTransferred(log types.Log) (*EspressoSGXTEEVerifierOwnershipTransferred, error) {
+	event := new(EspressoSGXTEEVerifierOwnershipTransferred)
+	if err := _EspressoSGXTEEVerifier.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierSignerRegisteredIterator is returned from FilterSignerRegistered and is used to iterate over the raw logs and unpacked data for SignerRegistered events raised by the EspressoSGXTEEVerifier contract.
+type EspressoSGXTEEVerifierSignerRegisteredIterator struct {
+	Event *EspressoSGXTEEVerifierSignerRegistered // 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 *EspressoSGXTEEVerifierSignerRegisteredIterator) 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(EspressoSGXTEEVerifierSignerRegistered)
+			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(EspressoSGXTEEVerifierSignerRegistered)
+		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 *EspressoSGXTEEVerifierSignerRegisteredIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierSignerRegisteredIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierSignerRegistered represents a SignerRegistered event raised by the EspressoSGXTEEVerifier contract.
+type EspressoSGXTEEVerifierSignerRegistered struct {
+	Signer      common.Address
+	EnclaveHash [32]byte
+	Raw         types.Log // Blockchain specific contextual infos
+}
+
+// FilterSignerRegistered is a free log retrieval operation binding the contract event 0xcf848c482fcf6fe3067875f261b92c8f20a9756538ee17b8ef66ad0b7bae208c.
+//
+// Solidity: event SignerRegistered(address signer, bytes32 enclaveHash)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) FilterSignerRegistered(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierSignerRegisteredIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifier.contract.FilterLogs(opts, "SignerRegistered")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierSignerRegisteredIterator{contract: _EspressoSGXTEEVerifier.contract, event: "SignerRegistered", logs: logs, sub: sub}, nil
+}
+
+// WatchSignerRegistered is a free log subscription operation binding the contract event 0xcf848c482fcf6fe3067875f261b92c8f20a9756538ee17b8ef66ad0b7bae208c.
+//
+// Solidity: event SignerRegistered(address signer, bytes32 enclaveHash)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) WatchSignerRegistered(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierSignerRegistered) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifier.contract.WatchLogs(opts, "SignerRegistered")
+	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(EspressoSGXTEEVerifierSignerRegistered)
+				if err := _EspressoSGXTEEVerifier.contract.UnpackLog(event, "SignerRegistered", 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
+}
+
+// ParseSignerRegistered is a log parse operation binding the contract event 0xcf848c482fcf6fe3067875f261b92c8f20a9756538ee17b8ef66ad0b7bae208c.
+//
+// Solidity: event SignerRegistered(address signer, bytes32 enclaveHash)
+func (_EspressoSGXTEEVerifier *EspressoSGXTEEVerifierFilterer) ParseSignerRegistered(log types.Log) (*EspressoSGXTEEVerifierSignerRegistered, error) {
+	event := new(EspressoSGXTEEVerifierSignerRegistered)
+	if err := _EspressoSGXTEEVerifier.contract.UnpackLog(event, "SignerRegistered", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestMetaData contains all meta data concerning the EspressoSGXTEEVerifierTest contract.
+var EspressoSGXTEEVerifierTestMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testDeleteRegisteredSigner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testIncorrectMrEnclave\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testIncorrectReportDataHash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testOwnershipTransfer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testRegisterSigner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testRegisterSignerInvalidAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testRegisterSignerInvalidDataLength\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testRegisterSignerInvalidQuote\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testSetEnclaveHash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testVerifyInvalidHeaderInQuote\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testVerifyInvalidQuote\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testVerifyQuoteEmptyRawQuote\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testVerifyQuoteEmptyReportDataHash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testVerifyQuoteValid\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"}]",
+	Bin: "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",
+}
+
+// EspressoSGXTEEVerifierTestABI is the input ABI used to generate the binding from.
+// Deprecated: Use EspressoSGXTEEVerifierTestMetaData.ABI instead.
+var EspressoSGXTEEVerifierTestABI = EspressoSGXTEEVerifierTestMetaData.ABI
+
+// EspressoSGXTEEVerifierTestBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use EspressoSGXTEEVerifierTestMetaData.Bin instead.
+var EspressoSGXTEEVerifierTestBin = EspressoSGXTEEVerifierTestMetaData.Bin
+
+// DeployEspressoSGXTEEVerifierTest deploys a new Ethereum contract, binding an instance of EspressoSGXTEEVerifierTest to it.
+func DeployEspressoSGXTEEVerifierTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *EspressoSGXTEEVerifierTest, error) {
+	parsed, err := EspressoSGXTEEVerifierTestMetaData.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(EspressoSGXTEEVerifierTestBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &EspressoSGXTEEVerifierTest{EspressoSGXTEEVerifierTestCaller: EspressoSGXTEEVerifierTestCaller{contract: contract}, EspressoSGXTEEVerifierTestTransactor: EspressoSGXTEEVerifierTestTransactor{contract: contract}, EspressoSGXTEEVerifierTestFilterer: EspressoSGXTEEVerifierTestFilterer{contract: contract}}, nil
+}
+
+// EspressoSGXTEEVerifierTest is an auto generated Go binding around an Ethereum contract.
+type EspressoSGXTEEVerifierTest struct {
+	EspressoSGXTEEVerifierTestCaller     // Read-only binding to the contract
+	EspressoSGXTEEVerifierTestTransactor // Write-only binding to the contract
+	EspressoSGXTEEVerifierTestFilterer   // Log filterer for contract events
+}
+
+// EspressoSGXTEEVerifierTestCaller is an auto generated read-only Go binding around an Ethereum contract.
+type EspressoSGXTEEVerifierTestCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoSGXTEEVerifierTestTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type EspressoSGXTEEVerifierTestTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoSGXTEEVerifierTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type EspressoSGXTEEVerifierTestFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoSGXTEEVerifierTestSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type EspressoSGXTEEVerifierTestSession struct {
+	Contract     *EspressoSGXTEEVerifierTest // 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
+}
+
+// EspressoSGXTEEVerifierTestCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type EspressoSGXTEEVerifierTestCallerSession struct {
+	Contract *EspressoSGXTEEVerifierTestCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts                     // Call options to use throughout this session
+}
+
+// EspressoSGXTEEVerifierTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type EspressoSGXTEEVerifierTestTransactorSession struct {
+	Contract     *EspressoSGXTEEVerifierTestTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts                     // Transaction auth options to use throughout this session
+}
+
+// EspressoSGXTEEVerifierTestRaw is an auto generated low-level Go binding around an Ethereum contract.
+type EspressoSGXTEEVerifierTestRaw struct {
+	Contract *EspressoSGXTEEVerifierTest // Generic contract binding to access the raw methods on
+}
+
+// EspressoSGXTEEVerifierTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type EspressoSGXTEEVerifierTestCallerRaw struct {
+	Contract *EspressoSGXTEEVerifierTestCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// EspressoSGXTEEVerifierTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type EspressoSGXTEEVerifierTestTransactorRaw struct {
+	Contract *EspressoSGXTEEVerifierTestTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewEspressoSGXTEEVerifierTest creates a new instance of EspressoSGXTEEVerifierTest, bound to a specific deployed contract.
+func NewEspressoSGXTEEVerifierTest(address common.Address, backend bind.ContractBackend) (*EspressoSGXTEEVerifierTest, error) {
+	contract, err := bindEspressoSGXTEEVerifierTest(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTest{EspressoSGXTEEVerifierTestCaller: EspressoSGXTEEVerifierTestCaller{contract: contract}, EspressoSGXTEEVerifierTestTransactor: EspressoSGXTEEVerifierTestTransactor{contract: contract}, EspressoSGXTEEVerifierTestFilterer: EspressoSGXTEEVerifierTestFilterer{contract: contract}}, nil
+}
+
+// NewEspressoSGXTEEVerifierTestCaller creates a new read-only instance of EspressoSGXTEEVerifierTest, bound to a specific deployed contract.
+func NewEspressoSGXTEEVerifierTestCaller(address common.Address, caller bind.ContractCaller) (*EspressoSGXTEEVerifierTestCaller, error) {
+	contract, err := bindEspressoSGXTEEVerifierTest(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestCaller{contract: contract}, nil
+}
+
+// NewEspressoSGXTEEVerifierTestTransactor creates a new write-only instance of EspressoSGXTEEVerifierTest, bound to a specific deployed contract.
+func NewEspressoSGXTEEVerifierTestTransactor(address common.Address, transactor bind.ContractTransactor) (*EspressoSGXTEEVerifierTestTransactor, error) {
+	contract, err := bindEspressoSGXTEEVerifierTest(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestTransactor{contract: contract}, nil
+}
+
+// NewEspressoSGXTEEVerifierTestFilterer creates a new log filterer instance of EspressoSGXTEEVerifierTest, bound to a specific deployed contract.
+func NewEspressoSGXTEEVerifierTestFilterer(address common.Address, filterer bind.ContractFilterer) (*EspressoSGXTEEVerifierTestFilterer, error) {
+	contract, err := bindEspressoSGXTEEVerifierTest(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestFilterer{contract: contract}, nil
+}
+
+// bindEspressoSGXTEEVerifierTest binds a generic wrapper to an already deployed contract.
+func bindEspressoSGXTEEVerifierTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := EspressoSGXTEEVerifierTestMetaData.GetAbi()
+	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 (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoSGXTEEVerifierTest.Contract.EspressoSGXTEEVerifierTestCaller.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 (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.EspressoSGXTEEVerifierTestTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.EspressoSGXTEEVerifierTestTransactor.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 (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoSGXTEEVerifierTest.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 (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.contract.Transact(opts, method, params...)
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCaller) ISTEST(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifierTest.contract.Call(opts, &out, "IS_TEST")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) ISTEST() (bool, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.ISTEST(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCallerSession) ISTEST() (bool, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.ISTEST(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCaller) ExcludeArtifacts(opts *bind.CallOpts) ([]string, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifierTest.contract.Call(opts, &out, "excludeArtifacts")
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) ExcludeArtifacts() ([]string, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.ExcludeArtifacts(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCallerSession) ExcludeArtifacts() ([]string, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.ExcludeArtifacts(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCaller) ExcludeContracts(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifierTest.contract.Call(opts, &out, "excludeContracts")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) ExcludeContracts() ([]common.Address, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.ExcludeContracts(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCallerSession) ExcludeContracts() ([]common.Address, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.ExcludeContracts(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCaller) ExcludeSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifierTest.contract.Call(opts, &out, "excludeSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector)
+
+	return out0, err
+
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.ExcludeSelectors(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCallerSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.ExcludeSelectors(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCaller) ExcludeSenders(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifierTest.contract.Call(opts, &out, "excludeSenders")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) ExcludeSenders() ([]common.Address, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.ExcludeSenders(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCallerSession) ExcludeSenders() ([]common.Address, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.ExcludeSenders(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCaller) Failed(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifierTest.contract.Call(opts, &out, "failed")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) Failed() (bool, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.Failed(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCallerSession) Failed() (bool, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.Failed(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCaller) TargetArtifactSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzArtifactSelector, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifierTest.contract.Call(opts, &out, "targetArtifactSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzArtifactSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzArtifactSelector)).(*[]StdInvariantFuzzArtifactSelector)
+
+	return out0, err
+
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TargetArtifactSelectors(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCallerSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TargetArtifactSelectors(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCaller) TargetArtifacts(opts *bind.CallOpts) ([]string, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifierTest.contract.Call(opts, &out, "targetArtifacts")
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TargetArtifacts() ([]string, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TargetArtifacts(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCallerSession) TargetArtifacts() ([]string, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TargetArtifacts(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCaller) TargetContracts(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifierTest.contract.Call(opts, &out, "targetContracts")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TargetContracts() ([]common.Address, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TargetContracts(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCallerSession) TargetContracts() ([]common.Address, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TargetContracts(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCaller) TargetInterfaces(opts *bind.CallOpts) ([]StdInvariantFuzzInterface, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifierTest.contract.Call(opts, &out, "targetInterfaces")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzInterface), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzInterface)).(*[]StdInvariantFuzzInterface)
+
+	return out0, err
+
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TargetInterfaces(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCallerSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TargetInterfaces(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCaller) TargetSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifierTest.contract.Call(opts, &out, "targetSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector)
+
+	return out0, err
+
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TargetSelectors(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCallerSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TargetSelectors(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCaller) TargetSenders(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoSGXTEEVerifierTest.contract.Call(opts, &out, "targetSenders")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TargetSenders() ([]common.Address, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TargetSenders(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestCallerSession) TargetSenders() ([]common.Address, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TargetSenders(&_EspressoSGXTEEVerifierTest.CallOpts)
+}
+
+// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4.
+//
+// Solidity: function setUp() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) SetUp(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "setUp")
+}
+
+// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4.
+//
+// Solidity: function setUp() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) SetUp() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.SetUp(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4.
+//
+// Solidity: function setUp() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) SetUp() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.SetUp(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestDeleteRegisteredSigner is a paid mutator transaction binding the contract method 0x20b0ffd5.
+//
+// Solidity: function testDeleteRegisteredSigner() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestDeleteRegisteredSigner(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testDeleteRegisteredSigner")
+}
+
+// TestDeleteRegisteredSigner is a paid mutator transaction binding the contract method 0x20b0ffd5.
+//
+// Solidity: function testDeleteRegisteredSigner() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestDeleteRegisteredSigner() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestDeleteRegisteredSigner(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestDeleteRegisteredSigner is a paid mutator transaction binding the contract method 0x20b0ffd5.
+//
+// Solidity: function testDeleteRegisteredSigner() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestDeleteRegisteredSigner() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestDeleteRegisteredSigner(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestIncorrectMrEnclave is a paid mutator transaction binding the contract method 0x4ff2514e.
+//
+// Solidity: function testIncorrectMrEnclave() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestIncorrectMrEnclave(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testIncorrectMrEnclave")
+}
+
+// TestIncorrectMrEnclave is a paid mutator transaction binding the contract method 0x4ff2514e.
+//
+// Solidity: function testIncorrectMrEnclave() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestIncorrectMrEnclave() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestIncorrectMrEnclave(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestIncorrectMrEnclave is a paid mutator transaction binding the contract method 0x4ff2514e.
+//
+// Solidity: function testIncorrectMrEnclave() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestIncorrectMrEnclave() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestIncorrectMrEnclave(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestIncorrectReportDataHash is a paid mutator transaction binding the contract method 0xc2871953.
+//
+// Solidity: function testIncorrectReportDataHash() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestIncorrectReportDataHash(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testIncorrectReportDataHash")
+}
+
+// TestIncorrectReportDataHash is a paid mutator transaction binding the contract method 0xc2871953.
+//
+// Solidity: function testIncorrectReportDataHash() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestIncorrectReportDataHash() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestIncorrectReportDataHash(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestIncorrectReportDataHash is a paid mutator transaction binding the contract method 0xc2871953.
+//
+// Solidity: function testIncorrectReportDataHash() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestIncorrectReportDataHash() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestIncorrectReportDataHash(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestOwnershipTransfer is a paid mutator transaction binding the contract method 0x575fc5d5.
+//
+// Solidity: function testOwnershipTransfer() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestOwnershipTransfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testOwnershipTransfer")
+}
+
+// TestOwnershipTransfer is a paid mutator transaction binding the contract method 0x575fc5d5.
+//
+// Solidity: function testOwnershipTransfer() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestOwnershipTransfer() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestOwnershipTransfer(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestOwnershipTransfer is a paid mutator transaction binding the contract method 0x575fc5d5.
+//
+// Solidity: function testOwnershipTransfer() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestOwnershipTransfer() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestOwnershipTransfer(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSigner is a paid mutator transaction binding the contract method 0xfa94f83d.
+//
+// Solidity: function testRegisterSigner() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestRegisterSigner(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testRegisterSigner")
+}
+
+// TestRegisterSigner is a paid mutator transaction binding the contract method 0xfa94f83d.
+//
+// Solidity: function testRegisterSigner() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestRegisterSigner() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestRegisterSigner(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSigner is a paid mutator transaction binding the contract method 0xfa94f83d.
+//
+// Solidity: function testRegisterSigner() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestRegisterSigner() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestRegisterSigner(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSignerInvalidAddress is a paid mutator transaction binding the contract method 0x063ab8cd.
+//
+// Solidity: function testRegisterSignerInvalidAddress() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestRegisterSignerInvalidAddress(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testRegisterSignerInvalidAddress")
+}
+
+// TestRegisterSignerInvalidAddress is a paid mutator transaction binding the contract method 0x063ab8cd.
+//
+// Solidity: function testRegisterSignerInvalidAddress() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestRegisterSignerInvalidAddress() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestRegisterSignerInvalidAddress(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSignerInvalidAddress is a paid mutator transaction binding the contract method 0x063ab8cd.
+//
+// Solidity: function testRegisterSignerInvalidAddress() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestRegisterSignerInvalidAddress() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestRegisterSignerInvalidAddress(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSignerInvalidDataLength is a paid mutator transaction binding the contract method 0xfcd609c2.
+//
+// Solidity: function testRegisterSignerInvalidDataLength() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestRegisterSignerInvalidDataLength(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testRegisterSignerInvalidDataLength")
+}
+
+// TestRegisterSignerInvalidDataLength is a paid mutator transaction binding the contract method 0xfcd609c2.
+//
+// Solidity: function testRegisterSignerInvalidDataLength() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestRegisterSignerInvalidDataLength() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestRegisterSignerInvalidDataLength(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSignerInvalidDataLength is a paid mutator transaction binding the contract method 0xfcd609c2.
+//
+// Solidity: function testRegisterSignerInvalidDataLength() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestRegisterSignerInvalidDataLength() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestRegisterSignerInvalidDataLength(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSignerInvalidQuote is a paid mutator transaction binding the contract method 0x2c2e5c92.
+//
+// Solidity: function testRegisterSignerInvalidQuote() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestRegisterSignerInvalidQuote(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testRegisterSignerInvalidQuote")
+}
+
+// TestRegisterSignerInvalidQuote is a paid mutator transaction binding the contract method 0x2c2e5c92.
+//
+// Solidity: function testRegisterSignerInvalidQuote() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestRegisterSignerInvalidQuote() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestRegisterSignerInvalidQuote(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestRegisterSignerInvalidQuote is a paid mutator transaction binding the contract method 0x2c2e5c92.
+//
+// Solidity: function testRegisterSignerInvalidQuote() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestRegisterSignerInvalidQuote() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestRegisterSignerInvalidQuote(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestSetEnclaveHash is a paid mutator transaction binding the contract method 0x6044f526.
+//
+// Solidity: function testSetEnclaveHash() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestSetEnclaveHash(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testSetEnclaveHash")
+}
+
+// TestSetEnclaveHash is a paid mutator transaction binding the contract method 0x6044f526.
+//
+// Solidity: function testSetEnclaveHash() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestSetEnclaveHash() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestSetEnclaveHash(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestSetEnclaveHash is a paid mutator transaction binding the contract method 0x6044f526.
+//
+// Solidity: function testSetEnclaveHash() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestSetEnclaveHash() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestSetEnclaveHash(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyInvalidHeaderInQuote is a paid mutator transaction binding the contract method 0x7532dc98.
+//
+// Solidity: function testVerifyInvalidHeaderInQuote() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestVerifyInvalidHeaderInQuote(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testVerifyInvalidHeaderInQuote")
+}
+
+// TestVerifyInvalidHeaderInQuote is a paid mutator transaction binding the contract method 0x7532dc98.
+//
+// Solidity: function testVerifyInvalidHeaderInQuote() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestVerifyInvalidHeaderInQuote() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestVerifyInvalidHeaderInQuote(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyInvalidHeaderInQuote is a paid mutator transaction binding the contract method 0x7532dc98.
+//
+// Solidity: function testVerifyInvalidHeaderInQuote() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestVerifyInvalidHeaderInQuote() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestVerifyInvalidHeaderInQuote(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyInvalidQuote is a paid mutator transaction binding the contract method 0xa74a11b0.
+//
+// Solidity: function testVerifyInvalidQuote() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestVerifyInvalidQuote(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testVerifyInvalidQuote")
+}
+
+// TestVerifyInvalidQuote is a paid mutator transaction binding the contract method 0xa74a11b0.
+//
+// Solidity: function testVerifyInvalidQuote() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestVerifyInvalidQuote() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestVerifyInvalidQuote(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyInvalidQuote is a paid mutator transaction binding the contract method 0xa74a11b0.
+//
+// Solidity: function testVerifyInvalidQuote() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestVerifyInvalidQuote() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestVerifyInvalidQuote(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyQuoteEmptyRawQuote is a paid mutator transaction binding the contract method 0xb058baa5.
+//
+// Solidity: function testVerifyQuoteEmptyRawQuote() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestVerifyQuoteEmptyRawQuote(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testVerifyQuoteEmptyRawQuote")
+}
+
+// TestVerifyQuoteEmptyRawQuote is a paid mutator transaction binding the contract method 0xb058baa5.
+//
+// Solidity: function testVerifyQuoteEmptyRawQuote() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestVerifyQuoteEmptyRawQuote() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestVerifyQuoteEmptyRawQuote(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyQuoteEmptyRawQuote is a paid mutator transaction binding the contract method 0xb058baa5.
+//
+// Solidity: function testVerifyQuoteEmptyRawQuote() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestVerifyQuoteEmptyRawQuote() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestVerifyQuoteEmptyRawQuote(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyQuoteEmptyReportDataHash is a paid mutator transaction binding the contract method 0xcb880b32.
+//
+// Solidity: function testVerifyQuoteEmptyReportDataHash() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestVerifyQuoteEmptyReportDataHash(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testVerifyQuoteEmptyReportDataHash")
+}
+
+// TestVerifyQuoteEmptyReportDataHash is a paid mutator transaction binding the contract method 0xcb880b32.
+//
+// Solidity: function testVerifyQuoteEmptyReportDataHash() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestVerifyQuoteEmptyReportDataHash() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestVerifyQuoteEmptyReportDataHash(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyQuoteEmptyReportDataHash is a paid mutator transaction binding the contract method 0xcb880b32.
+//
+// Solidity: function testVerifyQuoteEmptyReportDataHash() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestVerifyQuoteEmptyReportDataHash() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestVerifyQuoteEmptyReportDataHash(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyQuoteValid is a paid mutator transaction binding the contract method 0xca9ebc83.
+//
+// Solidity: function testVerifyQuoteValid() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactor) TestVerifyQuoteValid(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.contract.Transact(opts, "testVerifyQuoteValid")
+}
+
+// TestVerifyQuoteValid is a paid mutator transaction binding the contract method 0xca9ebc83.
+//
+// Solidity: function testVerifyQuoteValid() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestSession) TestVerifyQuoteValid() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestVerifyQuoteValid(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// TestVerifyQuoteValid is a paid mutator transaction binding the contract method 0xca9ebc83.
+//
+// Solidity: function testVerifyQuoteValid() returns()
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestTransactorSession) TestVerifyQuoteValid() (*types.Transaction, error) {
+	return _EspressoSGXTEEVerifierTest.Contract.TestVerifyQuoteValid(&_EspressoSGXTEEVerifierTest.TransactOpts)
+}
+
+// EspressoSGXTEEVerifierTestLogIterator is returned from FilterLog and is used to iterate over the raw logs and unpacked data for Log events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogIterator struct {
+	Event *EspressoSGXTEEVerifierTestLog // 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 *EspressoSGXTEEVerifierTestLogIterator) 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(EspressoSGXTEEVerifierTestLog)
+			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(EspressoSGXTEEVerifierTestLog)
+		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 *EspressoSGXTEEVerifierTestLogIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLog represents a Log event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLog struct {
+	Arg0 string
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLog is a free log retrieval operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLog(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log", logs: logs, sub: sub}, nil
+}
+
+// WatchLog is a free log subscription operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLog(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLog) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log")
+	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(EspressoSGXTEEVerifierTestLog)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log", 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
+}
+
+// ParseLog is a log parse operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLog(log types.Log) (*EspressoSGXTEEVerifierTestLog, error) {
+	event := new(EspressoSGXTEEVerifierTestLog)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogAddressIterator is returned from FilterLogAddress and is used to iterate over the raw logs and unpacked data for LogAddress events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogAddressIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogAddress // 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 *EspressoSGXTEEVerifierTestLogAddressIterator) 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(EspressoSGXTEEVerifierTestLogAddress)
+			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(EspressoSGXTEEVerifierTestLogAddress)
+		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 *EspressoSGXTEEVerifierTestLogAddressIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogAddressIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogAddress represents a LogAddress event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogAddress struct {
+	Arg0 common.Address
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogAddress is a free log retrieval operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogAddress(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogAddressIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_address")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogAddressIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_address", logs: logs, sub: sub}, nil
+}
+
+// WatchLogAddress is a free log subscription operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogAddress(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogAddress) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_address")
+	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(EspressoSGXTEEVerifierTestLogAddress)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_address", 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
+}
+
+// ParseLogAddress is a log parse operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogAddress(log types.Log) (*EspressoSGXTEEVerifierTestLogAddress, error) {
+	event := new(EspressoSGXTEEVerifierTestLogAddress)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_address", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogArrayIterator is returned from FilterLogArray and is used to iterate over the raw logs and unpacked data for LogArray events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogArrayIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogArray // 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 *EspressoSGXTEEVerifierTestLogArrayIterator) 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(EspressoSGXTEEVerifierTestLogArray)
+			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(EspressoSGXTEEVerifierTestLogArray)
+		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 *EspressoSGXTEEVerifierTestLogArrayIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogArrayIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogArray represents a LogArray event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogArray struct {
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray is a free log retrieval operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogArray(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogArrayIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_array")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogArrayIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_array", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray is a free log subscription operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogArray(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogArray) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_array")
+	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(EspressoSGXTEEVerifierTestLogArray)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_array", 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
+}
+
+// ParseLogArray is a log parse operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogArray(log types.Log) (*EspressoSGXTEEVerifierTestLogArray, error) {
+	event := new(EspressoSGXTEEVerifierTestLogArray)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_array", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogArray0Iterator is returned from FilterLogArray0 and is used to iterate over the raw logs and unpacked data for LogArray0 events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogArray0Iterator struct {
+	Event *EspressoSGXTEEVerifierTestLogArray0 // 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 *EspressoSGXTEEVerifierTestLogArray0Iterator) 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(EspressoSGXTEEVerifierTestLogArray0)
+			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(EspressoSGXTEEVerifierTestLogArray0)
+		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 *EspressoSGXTEEVerifierTestLogArray0Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogArray0Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogArray0 represents a LogArray0 event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogArray0 struct {
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray0 is a free log retrieval operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogArray0(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogArray0Iterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_array0")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogArray0Iterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_array0", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray0 is a free log subscription operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogArray0(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogArray0) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_array0")
+	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(EspressoSGXTEEVerifierTestLogArray0)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_array0", 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
+}
+
+// ParseLogArray0 is a log parse operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogArray0(log types.Log) (*EspressoSGXTEEVerifierTestLogArray0, error) {
+	event := new(EspressoSGXTEEVerifierTestLogArray0)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_array0", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogArray1Iterator is returned from FilterLogArray1 and is used to iterate over the raw logs and unpacked data for LogArray1 events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogArray1Iterator struct {
+	Event *EspressoSGXTEEVerifierTestLogArray1 // 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 *EspressoSGXTEEVerifierTestLogArray1Iterator) 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(EspressoSGXTEEVerifierTestLogArray1)
+			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(EspressoSGXTEEVerifierTestLogArray1)
+		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 *EspressoSGXTEEVerifierTestLogArray1Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogArray1Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogArray1 represents a LogArray1 event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogArray1 struct {
+	Val []common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray1 is a free log retrieval operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogArray1(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogArray1Iterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_array1")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogArray1Iterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_array1", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray1 is a free log subscription operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogArray1(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogArray1) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_array1")
+	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(EspressoSGXTEEVerifierTestLogArray1)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_array1", 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
+}
+
+// ParseLogArray1 is a log parse operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogArray1(log types.Log) (*EspressoSGXTEEVerifierTestLogArray1, error) {
+	event := new(EspressoSGXTEEVerifierTestLogArray1)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_array1", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogBytesIterator is returned from FilterLogBytes and is used to iterate over the raw logs and unpacked data for LogBytes events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogBytesIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogBytes // 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 *EspressoSGXTEEVerifierTestLogBytesIterator) 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(EspressoSGXTEEVerifierTestLogBytes)
+			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(EspressoSGXTEEVerifierTestLogBytes)
+		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 *EspressoSGXTEEVerifierTestLogBytesIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogBytesIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogBytes represents a LogBytes event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogBytes struct {
+	Arg0 []byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogBytes is a free log retrieval operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogBytes(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogBytesIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_bytes")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogBytesIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_bytes", logs: logs, sub: sub}, nil
+}
+
+// WatchLogBytes is a free log subscription operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogBytes(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogBytes) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_bytes")
+	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(EspressoSGXTEEVerifierTestLogBytes)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_bytes", 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
+}
+
+// ParseLogBytes is a log parse operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogBytes(log types.Log) (*EspressoSGXTEEVerifierTestLogBytes, error) {
+	event := new(EspressoSGXTEEVerifierTestLogBytes)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_bytes", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogBytes32Iterator is returned from FilterLogBytes32 and is used to iterate over the raw logs and unpacked data for LogBytes32 events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogBytes32Iterator struct {
+	Event *EspressoSGXTEEVerifierTestLogBytes32 // 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 *EspressoSGXTEEVerifierTestLogBytes32Iterator) 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(EspressoSGXTEEVerifierTestLogBytes32)
+			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(EspressoSGXTEEVerifierTestLogBytes32)
+		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 *EspressoSGXTEEVerifierTestLogBytes32Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogBytes32Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogBytes32 represents a LogBytes32 event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogBytes32 struct {
+	Arg0 [32]byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogBytes32 is a free log retrieval operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogBytes32(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogBytes32Iterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_bytes32")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogBytes32Iterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_bytes32", logs: logs, sub: sub}, nil
+}
+
+// WatchLogBytes32 is a free log subscription operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogBytes32(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogBytes32) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_bytes32")
+	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(EspressoSGXTEEVerifierTestLogBytes32)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_bytes32", 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
+}
+
+// ParseLogBytes32 is a log parse operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogBytes32(log types.Log) (*EspressoSGXTEEVerifierTestLogBytes32, error) {
+	event := new(EspressoSGXTEEVerifierTestLogBytes32)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_bytes32", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogIntIterator is returned from FilterLogInt and is used to iterate over the raw logs and unpacked data for LogInt events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogIntIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogInt // 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 *EspressoSGXTEEVerifierTestLogIntIterator) 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(EspressoSGXTEEVerifierTestLogInt)
+			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(EspressoSGXTEEVerifierTestLogInt)
+		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 *EspressoSGXTEEVerifierTestLogIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogInt represents a LogInt event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogInt struct {
+	Arg0 *big.Int
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogInt is a free log retrieval operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogInt(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogIntIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_int")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogIntIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogInt is a free log subscription operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogInt(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogInt) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_int")
+	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(EspressoSGXTEEVerifierTestLogInt)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_int", 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
+}
+
+// ParseLogInt is a log parse operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogInt(log types.Log) (*EspressoSGXTEEVerifierTestLogInt, error) {
+	event := new(EspressoSGXTEEVerifierTestLogInt)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedAddressIterator is returned from FilterLogNamedAddress and is used to iterate over the raw logs and unpacked data for LogNamedAddress events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedAddressIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogNamedAddress // 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 *EspressoSGXTEEVerifierTestLogNamedAddressIterator) 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(EspressoSGXTEEVerifierTestLogNamedAddress)
+			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(EspressoSGXTEEVerifierTestLogNamedAddress)
+		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 *EspressoSGXTEEVerifierTestLogNamedAddressIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogNamedAddressIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedAddress represents a LogNamedAddress event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedAddress struct {
+	Key string
+	Val common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedAddress is a free log retrieval operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogNamedAddress(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogNamedAddressIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_named_address")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogNamedAddressIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_named_address", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedAddress is a free log subscription operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogNamedAddress(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogNamedAddress) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_named_address")
+	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(EspressoSGXTEEVerifierTestLogNamedAddress)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_address", 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
+}
+
+// ParseLogNamedAddress is a log parse operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogNamedAddress(log types.Log) (*EspressoSGXTEEVerifierTestLogNamedAddress, error) {
+	event := new(EspressoSGXTEEVerifierTestLogNamedAddress)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_address", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedArrayIterator is returned from FilterLogNamedArray and is used to iterate over the raw logs and unpacked data for LogNamedArray events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedArrayIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogNamedArray // 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 *EspressoSGXTEEVerifierTestLogNamedArrayIterator) 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(EspressoSGXTEEVerifierTestLogNamedArray)
+			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(EspressoSGXTEEVerifierTestLogNamedArray)
+		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 *EspressoSGXTEEVerifierTestLogNamedArrayIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogNamedArrayIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedArray represents a LogNamedArray event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedArray struct {
+	Key string
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray is a free log retrieval operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogNamedArray(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogNamedArrayIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_named_array")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogNamedArrayIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_named_array", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray is a free log subscription operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogNamedArray(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogNamedArray) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_named_array")
+	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(EspressoSGXTEEVerifierTestLogNamedArray)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_array", 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
+}
+
+// ParseLogNamedArray is a log parse operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogNamedArray(log types.Log) (*EspressoSGXTEEVerifierTestLogNamedArray, error) {
+	event := new(EspressoSGXTEEVerifierTestLogNamedArray)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_array", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedArray0Iterator is returned from FilterLogNamedArray0 and is used to iterate over the raw logs and unpacked data for LogNamedArray0 events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedArray0Iterator struct {
+	Event *EspressoSGXTEEVerifierTestLogNamedArray0 // 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 *EspressoSGXTEEVerifierTestLogNamedArray0Iterator) 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(EspressoSGXTEEVerifierTestLogNamedArray0)
+			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(EspressoSGXTEEVerifierTestLogNamedArray0)
+		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 *EspressoSGXTEEVerifierTestLogNamedArray0Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogNamedArray0Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedArray0 represents a LogNamedArray0 event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedArray0 struct {
+	Key string
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray0 is a free log retrieval operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogNamedArray0(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogNamedArray0Iterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_named_array0")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogNamedArray0Iterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_named_array0", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray0 is a free log subscription operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogNamedArray0(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogNamedArray0) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_named_array0")
+	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(EspressoSGXTEEVerifierTestLogNamedArray0)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_array0", 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
+}
+
+// ParseLogNamedArray0 is a log parse operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogNamedArray0(log types.Log) (*EspressoSGXTEEVerifierTestLogNamedArray0, error) {
+	event := new(EspressoSGXTEEVerifierTestLogNamedArray0)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_array0", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedArray1Iterator is returned from FilterLogNamedArray1 and is used to iterate over the raw logs and unpacked data for LogNamedArray1 events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedArray1Iterator struct {
+	Event *EspressoSGXTEEVerifierTestLogNamedArray1 // 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 *EspressoSGXTEEVerifierTestLogNamedArray1Iterator) 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(EspressoSGXTEEVerifierTestLogNamedArray1)
+			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(EspressoSGXTEEVerifierTestLogNamedArray1)
+		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 *EspressoSGXTEEVerifierTestLogNamedArray1Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogNamedArray1Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedArray1 represents a LogNamedArray1 event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedArray1 struct {
+	Key string
+	Val []common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray1 is a free log retrieval operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogNamedArray1(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogNamedArray1Iterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_named_array1")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogNamedArray1Iterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_named_array1", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray1 is a free log subscription operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogNamedArray1(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogNamedArray1) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_named_array1")
+	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(EspressoSGXTEEVerifierTestLogNamedArray1)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_array1", 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
+}
+
+// ParseLogNamedArray1 is a log parse operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogNamedArray1(log types.Log) (*EspressoSGXTEEVerifierTestLogNamedArray1, error) {
+	event := new(EspressoSGXTEEVerifierTestLogNamedArray1)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_array1", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedBytesIterator is returned from FilterLogNamedBytes and is used to iterate over the raw logs and unpacked data for LogNamedBytes events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedBytesIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogNamedBytes // 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 *EspressoSGXTEEVerifierTestLogNamedBytesIterator) 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(EspressoSGXTEEVerifierTestLogNamedBytes)
+			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(EspressoSGXTEEVerifierTestLogNamedBytes)
+		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 *EspressoSGXTEEVerifierTestLogNamedBytesIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogNamedBytesIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedBytes represents a LogNamedBytes event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedBytes struct {
+	Key string
+	Val []byte
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedBytes is a free log retrieval operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogNamedBytes(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogNamedBytesIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_named_bytes")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogNamedBytesIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_named_bytes", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedBytes is a free log subscription operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogNamedBytes(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogNamedBytes) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_named_bytes")
+	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(EspressoSGXTEEVerifierTestLogNamedBytes)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_bytes", 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
+}
+
+// ParseLogNamedBytes is a log parse operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogNamedBytes(log types.Log) (*EspressoSGXTEEVerifierTestLogNamedBytes, error) {
+	event := new(EspressoSGXTEEVerifierTestLogNamedBytes)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_bytes", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedBytes32Iterator is returned from FilterLogNamedBytes32 and is used to iterate over the raw logs and unpacked data for LogNamedBytes32 events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedBytes32Iterator struct {
+	Event *EspressoSGXTEEVerifierTestLogNamedBytes32 // 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 *EspressoSGXTEEVerifierTestLogNamedBytes32Iterator) 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(EspressoSGXTEEVerifierTestLogNamedBytes32)
+			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(EspressoSGXTEEVerifierTestLogNamedBytes32)
+		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 *EspressoSGXTEEVerifierTestLogNamedBytes32Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogNamedBytes32Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedBytes32 represents a LogNamedBytes32 event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedBytes32 struct {
+	Key string
+	Val [32]byte
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedBytes32 is a free log retrieval operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogNamedBytes32(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogNamedBytes32Iterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_named_bytes32")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogNamedBytes32Iterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_named_bytes32", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedBytes32 is a free log subscription operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogNamedBytes32(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogNamedBytes32) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_named_bytes32")
+	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(EspressoSGXTEEVerifierTestLogNamedBytes32)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_bytes32", 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
+}
+
+// ParseLogNamedBytes32 is a log parse operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogNamedBytes32(log types.Log) (*EspressoSGXTEEVerifierTestLogNamedBytes32, error) {
+	event := new(EspressoSGXTEEVerifierTestLogNamedBytes32)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_bytes32", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedDecimalIntIterator is returned from FilterLogNamedDecimalInt and is used to iterate over the raw logs and unpacked data for LogNamedDecimalInt events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedDecimalIntIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogNamedDecimalInt // 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 *EspressoSGXTEEVerifierTestLogNamedDecimalIntIterator) 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(EspressoSGXTEEVerifierTestLogNamedDecimalInt)
+			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(EspressoSGXTEEVerifierTestLogNamedDecimalInt)
+		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 *EspressoSGXTEEVerifierTestLogNamedDecimalIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogNamedDecimalIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedDecimalInt represents a LogNamedDecimalInt event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedDecimalInt struct {
+	Key      string
+	Val      *big.Int
+	Decimals *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedDecimalInt is a free log retrieval operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogNamedDecimalInt(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogNamedDecimalIntIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_named_decimal_int")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogNamedDecimalIntIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_named_decimal_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedDecimalInt is a free log subscription operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogNamedDecimalInt(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogNamedDecimalInt) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_named_decimal_int")
+	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(EspressoSGXTEEVerifierTestLogNamedDecimalInt)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_decimal_int", 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
+}
+
+// ParseLogNamedDecimalInt is a log parse operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogNamedDecimalInt(log types.Log) (*EspressoSGXTEEVerifierTestLogNamedDecimalInt, error) {
+	event := new(EspressoSGXTEEVerifierTestLogNamedDecimalInt)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedDecimalUintIterator is returned from FilterLogNamedDecimalUint and is used to iterate over the raw logs and unpacked data for LogNamedDecimalUint events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedDecimalUintIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogNamedDecimalUint // 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 *EspressoSGXTEEVerifierTestLogNamedDecimalUintIterator) 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(EspressoSGXTEEVerifierTestLogNamedDecimalUint)
+			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(EspressoSGXTEEVerifierTestLogNamedDecimalUint)
+		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 *EspressoSGXTEEVerifierTestLogNamedDecimalUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogNamedDecimalUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedDecimalUint represents a LogNamedDecimalUint event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedDecimalUint struct {
+	Key      string
+	Val      *big.Int
+	Decimals *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedDecimalUint is a free log retrieval operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogNamedDecimalUint(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogNamedDecimalUintIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_named_decimal_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogNamedDecimalUintIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_named_decimal_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedDecimalUint is a free log subscription operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogNamedDecimalUint(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogNamedDecimalUint) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_named_decimal_uint")
+	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(EspressoSGXTEEVerifierTestLogNamedDecimalUint)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_decimal_uint", 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
+}
+
+// ParseLogNamedDecimalUint is a log parse operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogNamedDecimalUint(log types.Log) (*EspressoSGXTEEVerifierTestLogNamedDecimalUint, error) {
+	event := new(EspressoSGXTEEVerifierTestLogNamedDecimalUint)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedIntIterator is returned from FilterLogNamedInt and is used to iterate over the raw logs and unpacked data for LogNamedInt events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedIntIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogNamedInt // 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 *EspressoSGXTEEVerifierTestLogNamedIntIterator) 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(EspressoSGXTEEVerifierTestLogNamedInt)
+			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(EspressoSGXTEEVerifierTestLogNamedInt)
+		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 *EspressoSGXTEEVerifierTestLogNamedIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogNamedIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedInt represents a LogNamedInt event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedInt struct {
+	Key string
+	Val *big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedInt is a free log retrieval operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogNamedInt(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogNamedIntIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_named_int")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogNamedIntIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_named_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedInt is a free log subscription operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogNamedInt(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogNamedInt) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_named_int")
+	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(EspressoSGXTEEVerifierTestLogNamedInt)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_int", 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
+}
+
+// ParseLogNamedInt is a log parse operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogNamedInt(log types.Log) (*EspressoSGXTEEVerifierTestLogNamedInt, error) {
+	event := new(EspressoSGXTEEVerifierTestLogNamedInt)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedStringIterator is returned from FilterLogNamedString and is used to iterate over the raw logs and unpacked data for LogNamedString events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedStringIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogNamedString // 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 *EspressoSGXTEEVerifierTestLogNamedStringIterator) 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(EspressoSGXTEEVerifierTestLogNamedString)
+			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(EspressoSGXTEEVerifierTestLogNamedString)
+		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 *EspressoSGXTEEVerifierTestLogNamedStringIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogNamedStringIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedString represents a LogNamedString event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedString struct {
+	Key string
+	Val string
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedString is a free log retrieval operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogNamedString(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogNamedStringIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_named_string")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogNamedStringIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_named_string", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedString is a free log subscription operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogNamedString(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogNamedString) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_named_string")
+	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(EspressoSGXTEEVerifierTestLogNamedString)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_string", 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
+}
+
+// ParseLogNamedString is a log parse operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogNamedString(log types.Log) (*EspressoSGXTEEVerifierTestLogNamedString, error) {
+	event := new(EspressoSGXTEEVerifierTestLogNamedString)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_string", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedUintIterator is returned from FilterLogNamedUint and is used to iterate over the raw logs and unpacked data for LogNamedUint events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedUintIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogNamedUint // 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 *EspressoSGXTEEVerifierTestLogNamedUintIterator) 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(EspressoSGXTEEVerifierTestLogNamedUint)
+			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(EspressoSGXTEEVerifierTestLogNamedUint)
+		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 *EspressoSGXTEEVerifierTestLogNamedUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogNamedUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogNamedUint represents a LogNamedUint event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogNamedUint struct {
+	Key string
+	Val *big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedUint is a free log retrieval operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogNamedUint(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogNamedUintIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_named_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogNamedUintIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_named_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedUint is a free log subscription operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogNamedUint(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogNamedUint) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_named_uint")
+	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(EspressoSGXTEEVerifierTestLogNamedUint)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_uint", 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
+}
+
+// ParseLogNamedUint is a log parse operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogNamedUint(log types.Log) (*EspressoSGXTEEVerifierTestLogNamedUint, error) {
+	event := new(EspressoSGXTEEVerifierTestLogNamedUint)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_named_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogStringIterator is returned from FilterLogString and is used to iterate over the raw logs and unpacked data for LogString events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogStringIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogString // 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 *EspressoSGXTEEVerifierTestLogStringIterator) 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(EspressoSGXTEEVerifierTestLogString)
+			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(EspressoSGXTEEVerifierTestLogString)
+		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 *EspressoSGXTEEVerifierTestLogStringIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogStringIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogString represents a LogString event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogString struct {
+	Arg0 string
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogString is a free log retrieval operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogString(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogStringIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_string")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogStringIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_string", logs: logs, sub: sub}, nil
+}
+
+// WatchLogString is a free log subscription operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogString(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogString) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_string")
+	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(EspressoSGXTEEVerifierTestLogString)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_string", 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
+}
+
+// ParseLogString is a log parse operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogString(log types.Log) (*EspressoSGXTEEVerifierTestLogString, error) {
+	event := new(EspressoSGXTEEVerifierTestLogString)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_string", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogUintIterator is returned from FilterLogUint and is used to iterate over the raw logs and unpacked data for LogUint events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogUintIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogUint // 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 *EspressoSGXTEEVerifierTestLogUintIterator) 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(EspressoSGXTEEVerifierTestLogUint)
+			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(EspressoSGXTEEVerifierTestLogUint)
+		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 *EspressoSGXTEEVerifierTestLogUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogUint represents a LogUint event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogUint struct {
+	Arg0 *big.Int
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogUint is a free log retrieval operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogUint(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogUintIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "log_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogUintIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "log_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogUint is a free log subscription operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogUint(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogUint) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "log_uint")
+	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(EspressoSGXTEEVerifierTestLogUint)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_uint", 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
+}
+
+// ParseLogUint is a log parse operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogUint(log types.Log) (*EspressoSGXTEEVerifierTestLogUint, error) {
+	event := new(EspressoSGXTEEVerifierTestLogUint)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "log_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoSGXTEEVerifierTestLogsIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for Logs events raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogsIterator struct {
+	Event *EspressoSGXTEEVerifierTestLogs // 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 *EspressoSGXTEEVerifierTestLogsIterator) 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(EspressoSGXTEEVerifierTestLogs)
+			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(EspressoSGXTEEVerifierTestLogs)
+		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 *EspressoSGXTEEVerifierTestLogsIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoSGXTEEVerifierTestLogsIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoSGXTEEVerifierTestLogs represents a Logs event raised by the EspressoSGXTEEVerifierTest contract.
+type EspressoSGXTEEVerifierTestLogs struct {
+	Arg0 []byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogs is a free log retrieval operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) FilterLogs(opts *bind.FilterOpts) (*EspressoSGXTEEVerifierTestLogsIterator, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.FilterLogs(opts, "logs")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXTEEVerifierTestLogsIterator{contract: _EspressoSGXTEEVerifierTest.contract, event: "logs", logs: logs, sub: sub}, nil
+}
+
+// WatchLogs is a free log subscription operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) WatchLogs(opts *bind.WatchOpts, sink chan<- *EspressoSGXTEEVerifierTestLogs) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoSGXTEEVerifierTest.contract.WatchLogs(opts, "logs")
+	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(EspressoSGXTEEVerifierTestLogs)
+				if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "logs", 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
+}
+
+// ParseLogs is a log parse operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_EspressoSGXTEEVerifierTest *EspressoSGXTEEVerifierTestFilterer) ParseLogs(log types.Log) (*EspressoSGXTEEVerifierTestLogs, error) {
+	event := new(EspressoSGXTEEVerifierTestLogs)
+	if err := _EspressoSGXTEEVerifierTest.contract.UnpackLog(event, "logs", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierMetaData contains all meta data concerning the EspressoTEEVerifier contract.
+var EspressoTEEVerifierMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"contractIEspressoSGXTEEVerifier\",\"name\":\"_espressoSGXTEEVerifier\",\"type\":\"address\"},{\"internalType\":\"contractIEspressoNitroTEEVerifier\",\"name\":\"_espressoNitroTEEVerifier\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"espressoNitroTEEVerifier\",\"outputs\":[{\"internalType\":\"contractIEspressoNitroTEEVerifier\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"espressoSGXTEEVerifier\",\"outputs\":[{\"internalType\":\"contractIEspressoSGXTEEVerifier\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"attestation\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"enumIEspressoTEEVerifier.TeeType\",\"name\":\"teeType\",\"type\":\"uint8\"}],\"name\":\"registerSigner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"},{\"internalType\":\"enumIEspressoTEEVerifier.TeeType\",\"name\":\"teeType\",\"type\":\"uint8\"}],\"name\":\"registeredEnclaveHashes\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"enumIEspressoTEEVerifier.TeeType\",\"name\":\"teeType\",\"type\":\"uint8\"}],\"name\":\"registeredSigners\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractIEspressoNitroTEEVerifier\",\"name\":\"_espressoNitroTEEVerifier\",\"type\":\"address\"}],\"name\":\"setEspressoNitroTEEVerifier\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractIEspressoSGXTEEVerifier\",\"name\":\"_espressoSGXTEEVerifier\",\"type\":\"address\"}],\"name\":\"setEspressoSGXTEEVerifier\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"userDataHash\",\"type\":\"bytes32\"},{\"internalType\":\"enumIEspressoTEEVerifier.TeeType\",\"name\":\"teeType\",\"type\":\"uint8\"}],\"name\":\"verify\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"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\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnsupportedTeeType\",\"type\":\"error\"}]",
+	Bin: "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",
+}
+
+// EspressoTEEVerifierABI is the input ABI used to generate the binding from.
+// Deprecated: Use EspressoTEEVerifierMetaData.ABI instead.
+var EspressoTEEVerifierABI = EspressoTEEVerifierMetaData.ABI
+
+// EspressoTEEVerifierBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use EspressoTEEVerifierMetaData.Bin instead.
+var EspressoTEEVerifierBin = EspressoTEEVerifierMetaData.Bin
+
+// DeployEspressoTEEVerifier deploys a new Ethereum contract, binding an instance of EspressoTEEVerifier to it.
+func DeployEspressoTEEVerifier(auth *bind.TransactOpts, backend bind.ContractBackend, _espressoSGXTEEVerifier common.Address, _espressoNitroTEEVerifier common.Address) (common.Address, *types.Transaction, *EspressoTEEVerifier, error) {
+	parsed, err := EspressoTEEVerifierMetaData.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(EspressoTEEVerifierBin), backend, _espressoSGXTEEVerifier, _espressoNitroTEEVerifier)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &EspressoTEEVerifier{EspressoTEEVerifierCaller: EspressoTEEVerifierCaller{contract: contract}, EspressoTEEVerifierTransactor: EspressoTEEVerifierTransactor{contract: contract}, EspressoTEEVerifierFilterer: EspressoTEEVerifierFilterer{contract: contract}}, nil
+}
+
+// EspressoTEEVerifier is an auto generated Go binding around an Ethereum contract.
+type EspressoTEEVerifier struct {
+	EspressoTEEVerifierCaller     // Read-only binding to the contract
+	EspressoTEEVerifierTransactor // Write-only binding to the contract
+	EspressoTEEVerifierFilterer   // Log filterer for contract events
+}
+
+// EspressoTEEVerifierCaller is an auto generated read-only Go binding around an Ethereum contract.
+type EspressoTEEVerifierCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoTEEVerifierTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type EspressoTEEVerifierTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoTEEVerifierFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type EspressoTEEVerifierFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoTEEVerifierSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type EspressoTEEVerifierSession struct {
+	Contract     *EspressoTEEVerifier // 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
+}
+
+// EspressoTEEVerifierCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type EspressoTEEVerifierCallerSession struct {
+	Contract *EspressoTEEVerifierCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts              // Call options to use throughout this session
+}
+
+// EspressoTEEVerifierTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type EspressoTEEVerifierTransactorSession struct {
+	Contract     *EspressoTEEVerifierTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts              // Transaction auth options to use throughout this session
+}
+
+// EspressoTEEVerifierRaw is an auto generated low-level Go binding around an Ethereum contract.
+type EspressoTEEVerifierRaw struct {
+	Contract *EspressoTEEVerifier // Generic contract binding to access the raw methods on
+}
+
+// EspressoTEEVerifierCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type EspressoTEEVerifierCallerRaw struct {
+	Contract *EspressoTEEVerifierCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// EspressoTEEVerifierTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type EspressoTEEVerifierTransactorRaw struct {
+	Contract *EspressoTEEVerifierTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewEspressoTEEVerifier creates a new instance of EspressoTEEVerifier, bound to a specific deployed contract.
+func NewEspressoTEEVerifier(address common.Address, backend bind.ContractBackend) (*EspressoTEEVerifier, error) {
+	contract, err := bindEspressoTEEVerifier(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifier{EspressoTEEVerifierCaller: EspressoTEEVerifierCaller{contract: contract}, EspressoTEEVerifierTransactor: EspressoTEEVerifierTransactor{contract: contract}, EspressoTEEVerifierFilterer: EspressoTEEVerifierFilterer{contract: contract}}, nil
+}
+
+// NewEspressoTEEVerifierCaller creates a new read-only instance of EspressoTEEVerifier, bound to a specific deployed contract.
+func NewEspressoTEEVerifierCaller(address common.Address, caller bind.ContractCaller) (*EspressoTEEVerifierCaller, error) {
+	contract, err := bindEspressoTEEVerifier(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierCaller{contract: contract}, nil
+}
+
+// NewEspressoTEEVerifierTransactor creates a new write-only instance of EspressoTEEVerifier, bound to a specific deployed contract.
+func NewEspressoTEEVerifierTransactor(address common.Address, transactor bind.ContractTransactor) (*EspressoTEEVerifierTransactor, error) {
+	contract, err := bindEspressoTEEVerifier(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTransactor{contract: contract}, nil
+}
+
+// NewEspressoTEEVerifierFilterer creates a new log filterer instance of EspressoTEEVerifier, bound to a specific deployed contract.
+func NewEspressoTEEVerifierFilterer(address common.Address, filterer bind.ContractFilterer) (*EspressoTEEVerifierFilterer, error) {
+	contract, err := bindEspressoTEEVerifier(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierFilterer{contract: contract}, nil
+}
+
+// bindEspressoTEEVerifier binds a generic wrapper to an already deployed contract.
+func bindEspressoTEEVerifier(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := EspressoTEEVerifierMetaData.GetAbi()
+	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 (_EspressoTEEVerifier *EspressoTEEVerifierRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoTEEVerifier.Contract.EspressoTEEVerifierCaller.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 (_EspressoTEEVerifier *EspressoTEEVerifierRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.EspressoTEEVerifierTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoTEEVerifier *EspressoTEEVerifierRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.EspressoTEEVerifierTransactor.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 (_EspressoTEEVerifier *EspressoTEEVerifierCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoTEEVerifier.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 (_EspressoTEEVerifier *EspressoTEEVerifierTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoTEEVerifier *EspressoTEEVerifierTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.contract.Transact(opts, method, params...)
+}
+
+// EspressoNitroTEEVerifier is a free data retrieval call binding the contract method 0xd80a4c28.
+//
+// Solidity: function espressoNitroTEEVerifier() view returns(address)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCaller) EspressoNitroTEEVerifier(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifier.contract.Call(opts, &out, "espressoNitroTEEVerifier")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// EspressoNitroTEEVerifier is a free data retrieval call binding the contract method 0xd80a4c28.
+//
+// Solidity: function espressoNitroTEEVerifier() view returns(address)
+func (_EspressoTEEVerifier *EspressoTEEVerifierSession) EspressoNitroTEEVerifier() (common.Address, error) {
+	return _EspressoTEEVerifier.Contract.EspressoNitroTEEVerifier(&_EspressoTEEVerifier.CallOpts)
+}
+
+// EspressoNitroTEEVerifier is a free data retrieval call binding the contract method 0xd80a4c28.
+//
+// Solidity: function espressoNitroTEEVerifier() view returns(address)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCallerSession) EspressoNitroTEEVerifier() (common.Address, error) {
+	return _EspressoTEEVerifier.Contract.EspressoNitroTEEVerifier(&_EspressoTEEVerifier.CallOpts)
+}
+
+// EspressoSGXTEEVerifier is a free data retrieval call binding the contract method 0x80710c80.
+//
+// Solidity: function espressoSGXTEEVerifier() view returns(address)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCaller) EspressoSGXTEEVerifier(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifier.contract.Call(opts, &out, "espressoSGXTEEVerifier")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// EspressoSGXTEEVerifier is a free data retrieval call binding the contract method 0x80710c80.
+//
+// Solidity: function espressoSGXTEEVerifier() view returns(address)
+func (_EspressoTEEVerifier *EspressoTEEVerifierSession) EspressoSGXTEEVerifier() (common.Address, error) {
+	return _EspressoTEEVerifier.Contract.EspressoSGXTEEVerifier(&_EspressoTEEVerifier.CallOpts)
+}
+
+// EspressoSGXTEEVerifier is a free data retrieval call binding the contract method 0x80710c80.
+//
+// Solidity: function espressoSGXTEEVerifier() view returns(address)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCallerSession) EspressoSGXTEEVerifier() (common.Address, error) {
+	return _EspressoTEEVerifier.Contract.EspressoSGXTEEVerifier(&_EspressoTEEVerifier.CallOpts)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifier.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 (_EspressoTEEVerifier *EspressoTEEVerifierSession) Owner() (common.Address, error) {
+	return _EspressoTEEVerifier.Contract.Owner(&_EspressoTEEVerifier.CallOpts)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCallerSession) Owner() (common.Address, error) {
+	return _EspressoTEEVerifier.Contract.Owner(&_EspressoTEEVerifier.CallOpts)
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCaller) PendingOwner(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifier.contract.Call(opts, &out, "pendingOwner")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_EspressoTEEVerifier *EspressoTEEVerifierSession) PendingOwner() (common.Address, error) {
+	return _EspressoTEEVerifier.Contract.PendingOwner(&_EspressoTEEVerifier.CallOpts)
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCallerSession) PendingOwner() (common.Address, error) {
+	return _EspressoTEEVerifier.Contract.PendingOwner(&_EspressoTEEVerifier.CallOpts)
+}
+
+// RegisteredEnclaveHashes is a free data retrieval call binding the contract method 0x3cbe6803.
+//
+// Solidity: function registeredEnclaveHashes(bytes32 enclaveHash, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCaller) RegisteredEnclaveHashes(opts *bind.CallOpts, enclaveHash [32]byte, teeType uint8) (bool, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifier.contract.Call(opts, &out, "registeredEnclaveHashes", enclaveHash, teeType)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredEnclaveHashes is a free data retrieval call binding the contract method 0x3cbe6803.
+//
+// Solidity: function registeredEnclaveHashes(bytes32 enclaveHash, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifier *EspressoTEEVerifierSession) RegisteredEnclaveHashes(enclaveHash [32]byte, teeType uint8) (bool, error) {
+	return _EspressoTEEVerifier.Contract.RegisteredEnclaveHashes(&_EspressoTEEVerifier.CallOpts, enclaveHash, teeType)
+}
+
+// RegisteredEnclaveHashes is a free data retrieval call binding the contract method 0x3cbe6803.
+//
+// Solidity: function registeredEnclaveHashes(bytes32 enclaveHash, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCallerSession) RegisteredEnclaveHashes(enclaveHash [32]byte, teeType uint8) (bool, error) {
+	return _EspressoTEEVerifier.Contract.RegisteredEnclaveHashes(&_EspressoTEEVerifier.CallOpts, enclaveHash, teeType)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0xe9b1a7be.
+//
+// Solidity: function registeredSigners(address signer, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCaller) RegisteredSigners(opts *bind.CallOpts, signer common.Address, teeType uint8) (bool, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifier.contract.Call(opts, &out, "registeredSigners", signer, teeType)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0xe9b1a7be.
+//
+// Solidity: function registeredSigners(address signer, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifier *EspressoTEEVerifierSession) RegisteredSigners(signer common.Address, teeType uint8) (bool, error) {
+	return _EspressoTEEVerifier.Contract.RegisteredSigners(&_EspressoTEEVerifier.CallOpts, signer, teeType)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0xe9b1a7be.
+//
+// Solidity: function registeredSigners(address signer, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCallerSession) RegisteredSigners(signer common.Address, teeType uint8) (bool, error) {
+	return _EspressoTEEVerifier.Contract.RegisteredSigners(&_EspressoTEEVerifier.CallOpts, signer, teeType)
+}
+
+// Verify is a free data retrieval call binding the contract method 0xa81d9c5c.
+//
+// Solidity: function verify(bytes signature, bytes32 userDataHash, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCaller) Verify(opts *bind.CallOpts, signature []byte, userDataHash [32]byte, teeType uint8) (bool, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifier.contract.Call(opts, &out, "verify", signature, userDataHash, teeType)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// Verify is a free data retrieval call binding the contract method 0xa81d9c5c.
+//
+// Solidity: function verify(bytes signature, bytes32 userDataHash, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifier *EspressoTEEVerifierSession) Verify(signature []byte, userDataHash [32]byte, teeType uint8) (bool, error) {
+	return _EspressoTEEVerifier.Contract.Verify(&_EspressoTEEVerifier.CallOpts, signature, userDataHash, teeType)
+}
+
+// Verify is a free data retrieval call binding the contract method 0xa81d9c5c.
+//
+// Solidity: function verify(bytes signature, bytes32 userDataHash, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifier *EspressoTEEVerifierCallerSession) Verify(signature []byte, userDataHash [32]byte, teeType uint8) (bool, error) {
+	return _EspressoTEEVerifier.Contract.Verify(&_EspressoTEEVerifier.CallOpts, signature, userDataHash, teeType)
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierTransactor) AcceptOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.contract.Transact(opts, "acceptOwnership")
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierSession) AcceptOwnership() (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.AcceptOwnership(&_EspressoTEEVerifier.TransactOpts)
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierTransactorSession) AcceptOwnership() (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.AcceptOwnership(&_EspressoTEEVerifier.TransactOpts)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0x35ecb4c1.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data, uint8 teeType) returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierTransactor) RegisterSigner(opts *bind.TransactOpts, attestation []byte, data []byte, teeType uint8) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.contract.Transact(opts, "registerSigner", attestation, data, teeType)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0x35ecb4c1.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data, uint8 teeType) returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierSession) RegisterSigner(attestation []byte, data []byte, teeType uint8) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.RegisterSigner(&_EspressoTEEVerifier.TransactOpts, attestation, data, teeType)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0x35ecb4c1.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data, uint8 teeType) returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierTransactorSession) RegisterSigner(attestation []byte, data []byte, teeType uint8) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.RegisterSigner(&_EspressoTEEVerifier.TransactOpts, attestation, data, teeType)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.contract.Transact(opts, "renounceOwnership")
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierSession) RenounceOwnership() (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.RenounceOwnership(&_EspressoTEEVerifier.TransactOpts)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierTransactorSession) RenounceOwnership() (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.RenounceOwnership(&_EspressoTEEVerifier.TransactOpts)
+}
+
+// SetEspressoNitroTEEVerifier is a paid mutator transaction binding the contract method 0x330282f5.
+//
+// Solidity: function setEspressoNitroTEEVerifier(address _espressoNitroTEEVerifier) returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierTransactor) SetEspressoNitroTEEVerifier(opts *bind.TransactOpts, _espressoNitroTEEVerifier common.Address) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.contract.Transact(opts, "setEspressoNitroTEEVerifier", _espressoNitroTEEVerifier)
+}
+
+// SetEspressoNitroTEEVerifier is a paid mutator transaction binding the contract method 0x330282f5.
+//
+// Solidity: function setEspressoNitroTEEVerifier(address _espressoNitroTEEVerifier) returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierSession) SetEspressoNitroTEEVerifier(_espressoNitroTEEVerifier common.Address) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.SetEspressoNitroTEEVerifier(&_EspressoTEEVerifier.TransactOpts, _espressoNitroTEEVerifier)
+}
+
+// SetEspressoNitroTEEVerifier is a paid mutator transaction binding the contract method 0x330282f5.
+//
+// Solidity: function setEspressoNitroTEEVerifier(address _espressoNitroTEEVerifier) returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierTransactorSession) SetEspressoNitroTEEVerifier(_espressoNitroTEEVerifier common.Address) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.SetEspressoNitroTEEVerifier(&_EspressoTEEVerifier.TransactOpts, _espressoNitroTEEVerifier)
+}
+
+// SetEspressoSGXTEEVerifier is a paid mutator transaction binding the contract method 0xbc3a0911.
+//
+// Solidity: function setEspressoSGXTEEVerifier(address _espressoSGXTEEVerifier) returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierTransactor) SetEspressoSGXTEEVerifier(opts *bind.TransactOpts, _espressoSGXTEEVerifier common.Address) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.contract.Transact(opts, "setEspressoSGXTEEVerifier", _espressoSGXTEEVerifier)
+}
+
+// SetEspressoSGXTEEVerifier is a paid mutator transaction binding the contract method 0xbc3a0911.
+//
+// Solidity: function setEspressoSGXTEEVerifier(address _espressoSGXTEEVerifier) returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierSession) SetEspressoSGXTEEVerifier(_espressoSGXTEEVerifier common.Address) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.SetEspressoSGXTEEVerifier(&_EspressoTEEVerifier.TransactOpts, _espressoSGXTEEVerifier)
+}
+
+// SetEspressoSGXTEEVerifier is a paid mutator transaction binding the contract method 0xbc3a0911.
+//
+// Solidity: function setEspressoSGXTEEVerifier(address _espressoSGXTEEVerifier) returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierTransactorSession) SetEspressoSGXTEEVerifier(_espressoSGXTEEVerifier common.Address) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.SetEspressoSGXTEEVerifier(&_EspressoTEEVerifier.TransactOpts, _espressoSGXTEEVerifier)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.contract.Transact(opts, "transferOwnership", newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.TransferOwnership(&_EspressoTEEVerifier.TransactOpts, newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_EspressoTEEVerifier *EspressoTEEVerifierTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _EspressoTEEVerifier.Contract.TransferOwnership(&_EspressoTEEVerifier.TransactOpts, newOwner)
+}
+
+// EspressoTEEVerifierOwnershipTransferStartedIterator is returned from FilterOwnershipTransferStarted and is used to iterate over the raw logs and unpacked data for OwnershipTransferStarted events raised by the EspressoTEEVerifier contract.
+type EspressoTEEVerifierOwnershipTransferStartedIterator struct {
+	Event *EspressoTEEVerifierOwnershipTransferStarted // 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 *EspressoTEEVerifierOwnershipTransferStartedIterator) 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(EspressoTEEVerifierOwnershipTransferStarted)
+			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(EspressoTEEVerifierOwnershipTransferStarted)
+		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 *EspressoTEEVerifierOwnershipTransferStartedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierOwnershipTransferStartedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierOwnershipTransferStarted represents a OwnershipTransferStarted event raised by the EspressoTEEVerifier contract.
+type EspressoTEEVerifierOwnershipTransferStarted struct {
+	PreviousOwner common.Address
+	NewOwner      common.Address
+	Raw           types.Log // Blockchain specific contextual infos
+}
+
+// FilterOwnershipTransferStarted is a free log retrieval operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_EspressoTEEVerifier *EspressoTEEVerifierFilterer) FilterOwnershipTransferStarted(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*EspressoTEEVerifierOwnershipTransferStartedIterator, 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 := _EspressoTEEVerifier.contract.FilterLogs(opts, "OwnershipTransferStarted", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierOwnershipTransferStartedIterator{contract: _EspressoTEEVerifier.contract, event: "OwnershipTransferStarted", logs: logs, sub: sub}, nil
+}
+
+// WatchOwnershipTransferStarted is a free log subscription operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_EspressoTEEVerifier *EspressoTEEVerifierFilterer) WatchOwnershipTransferStarted(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierOwnershipTransferStarted, 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 := _EspressoTEEVerifier.contract.WatchLogs(opts, "OwnershipTransferStarted", 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(EspressoTEEVerifierOwnershipTransferStarted)
+				if err := _EspressoTEEVerifier.contract.UnpackLog(event, "OwnershipTransferStarted", 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
+}
+
+// ParseOwnershipTransferStarted is a log parse operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_EspressoTEEVerifier *EspressoTEEVerifierFilterer) ParseOwnershipTransferStarted(log types.Log) (*EspressoTEEVerifierOwnershipTransferStarted, error) {
+	event := new(EspressoTEEVerifierOwnershipTransferStarted)
+	if err := _EspressoTEEVerifier.contract.UnpackLog(event, "OwnershipTransferStarted", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the EspressoTEEVerifier contract.
+type EspressoTEEVerifierOwnershipTransferredIterator struct {
+	Event *EspressoTEEVerifierOwnershipTransferred // 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 *EspressoTEEVerifierOwnershipTransferredIterator) 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(EspressoTEEVerifierOwnershipTransferred)
+			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(EspressoTEEVerifierOwnershipTransferred)
+		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 *EspressoTEEVerifierOwnershipTransferredIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierOwnershipTransferredIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierOwnershipTransferred represents a OwnershipTransferred event raised by the EspressoTEEVerifier contract.
+type EspressoTEEVerifierOwnershipTransferred 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 (_EspressoTEEVerifier *EspressoTEEVerifierFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*EspressoTEEVerifierOwnershipTransferredIterator, 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 := _EspressoTEEVerifier.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierOwnershipTransferredIterator{contract: _EspressoTEEVerifier.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 (_EspressoTEEVerifier *EspressoTEEVerifierFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierOwnershipTransferred, 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 := _EspressoTEEVerifier.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(EspressoTEEVerifierOwnershipTransferred)
+				if err := _EspressoTEEVerifier.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 (_EspressoTEEVerifier *EspressoTEEVerifierFilterer) ParseOwnershipTransferred(log types.Log) (*EspressoTEEVerifierOwnershipTransferred, error) {
+	event := new(EspressoTEEVerifierOwnershipTransferred)
+	if err := _EspressoTEEVerifier.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierMockMetaData contains all meta data concerning the EspressoTEEVerifierMock contract.
+var EspressoTEEVerifierMockMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"attestation\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"enumEspressoTEEVerifierMock.TeeType\",\"name\":\"teeType\",\"type\":\"uint8\"}],\"name\":\"registerSigner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"registeredSigner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"enumEspressoTEEVerifierMock.TeeType\",\"name\":\"teeType\",\"type\":\"uint8\"}],\"name\":\"registeredSigners\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"userDataHash\",\"type\":\"bytes32\"},{\"internalType\":\"enumEspressoTEEVerifierMock.TeeType\",\"name\":\"teeType\",\"type\":\"uint8\"}],\"name\":\"verify\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+	Bin: "0x6080806040523460155761024b908161001a8239f35b5f80fdfe6080604090808252600480361015610015575f80fd5b5f3560e01c91826335ecb4c11461011657508163a81d9c5c146100cf57508063defc69ec146100945763e9b1a7be1461004c575f80fd5b346100905780600319360112610090576100646101ff565b90600260243510156100905760209160018060a01b03165f525f825260ff815f20541690519015158152f35b5f80fd5b5034610090576020366003190112610090576020906001600160a01b036100b96101ff565b165f525f825260ff815f20541690519015158152f35b905034610090576060366003190112610090578035906001600160401b038211610090576100ff913691016101d2565b505060026044351015610090576020905160018152f35b90915034610090576060366003190112610090576001600160401b0382358181116100905761014890369085016101d2565b50506024359081116100905761016190369084016101d2565b91909260026044351015610090576014830361019b575050601411610090573560601c5f908152602081905220805460ff19166001179055005b62461bcd60e51b82526020908201526013602482015272092dcecc2d8d2c840c8c2e8c240d8cadccee8d606b1b6044820152606490fd5b9181601f84011215610090578235916001600160401b038311610090576020838186019501011161009057565b600435906001600160a01b03821682036100905756fea2646970667358221220cc1bcfdf520a26c7cbd7f205c6127dd79c983c51a00adf8f97b43b9f81dd190064736f6c63430008190033",
+}
+
+// EspressoTEEVerifierMockABI is the input ABI used to generate the binding from.
+// Deprecated: Use EspressoTEEVerifierMockMetaData.ABI instead.
+var EspressoTEEVerifierMockABI = EspressoTEEVerifierMockMetaData.ABI
+
+// EspressoTEEVerifierMockBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use EspressoTEEVerifierMockMetaData.Bin instead.
+var EspressoTEEVerifierMockBin = EspressoTEEVerifierMockMetaData.Bin
+
+// DeployEspressoTEEVerifierMock deploys a new Ethereum contract, binding an instance of EspressoTEEVerifierMock to it.
+func DeployEspressoTEEVerifierMock(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *EspressoTEEVerifierMock, error) {
+	parsed, err := EspressoTEEVerifierMockMetaData.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(EspressoTEEVerifierMockBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &EspressoTEEVerifierMock{EspressoTEEVerifierMockCaller: EspressoTEEVerifierMockCaller{contract: contract}, EspressoTEEVerifierMockTransactor: EspressoTEEVerifierMockTransactor{contract: contract}, EspressoTEEVerifierMockFilterer: EspressoTEEVerifierMockFilterer{contract: contract}}, nil
+}
+
+// EspressoTEEVerifierMock is an auto generated Go binding around an Ethereum contract.
+type EspressoTEEVerifierMock struct {
+	EspressoTEEVerifierMockCaller     // Read-only binding to the contract
+	EspressoTEEVerifierMockTransactor // Write-only binding to the contract
+	EspressoTEEVerifierMockFilterer   // Log filterer for contract events
+}
+
+// EspressoTEEVerifierMockCaller is an auto generated read-only Go binding around an Ethereum contract.
+type EspressoTEEVerifierMockCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoTEEVerifierMockTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type EspressoTEEVerifierMockTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoTEEVerifierMockFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type EspressoTEEVerifierMockFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoTEEVerifierMockSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type EspressoTEEVerifierMockSession struct {
+	Contract     *EspressoTEEVerifierMock // 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
+}
+
+// EspressoTEEVerifierMockCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type EspressoTEEVerifierMockCallerSession struct {
+	Contract *EspressoTEEVerifierMockCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts                  // Call options to use throughout this session
+}
+
+// EspressoTEEVerifierMockTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type EspressoTEEVerifierMockTransactorSession struct {
+	Contract     *EspressoTEEVerifierMockTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts                  // Transaction auth options to use throughout this session
+}
+
+// EspressoTEEVerifierMockRaw is an auto generated low-level Go binding around an Ethereum contract.
+type EspressoTEEVerifierMockRaw struct {
+	Contract *EspressoTEEVerifierMock // Generic contract binding to access the raw methods on
+}
+
+// EspressoTEEVerifierMockCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type EspressoTEEVerifierMockCallerRaw struct {
+	Contract *EspressoTEEVerifierMockCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// EspressoTEEVerifierMockTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type EspressoTEEVerifierMockTransactorRaw struct {
+	Contract *EspressoTEEVerifierMockTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewEspressoTEEVerifierMock creates a new instance of EspressoTEEVerifierMock, bound to a specific deployed contract.
+func NewEspressoTEEVerifierMock(address common.Address, backend bind.ContractBackend) (*EspressoTEEVerifierMock, error) {
+	contract, err := bindEspressoTEEVerifierMock(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierMock{EspressoTEEVerifierMockCaller: EspressoTEEVerifierMockCaller{contract: contract}, EspressoTEEVerifierMockTransactor: EspressoTEEVerifierMockTransactor{contract: contract}, EspressoTEEVerifierMockFilterer: EspressoTEEVerifierMockFilterer{contract: contract}}, nil
+}
+
+// NewEspressoTEEVerifierMockCaller creates a new read-only instance of EspressoTEEVerifierMock, bound to a specific deployed contract.
+func NewEspressoTEEVerifierMockCaller(address common.Address, caller bind.ContractCaller) (*EspressoTEEVerifierMockCaller, error) {
+	contract, err := bindEspressoTEEVerifierMock(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierMockCaller{contract: contract}, nil
+}
+
+// NewEspressoTEEVerifierMockTransactor creates a new write-only instance of EspressoTEEVerifierMock, bound to a specific deployed contract.
+func NewEspressoTEEVerifierMockTransactor(address common.Address, transactor bind.ContractTransactor) (*EspressoTEEVerifierMockTransactor, error) {
+	contract, err := bindEspressoTEEVerifierMock(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierMockTransactor{contract: contract}, nil
+}
+
+// NewEspressoTEEVerifierMockFilterer creates a new log filterer instance of EspressoTEEVerifierMock, bound to a specific deployed contract.
+func NewEspressoTEEVerifierMockFilterer(address common.Address, filterer bind.ContractFilterer) (*EspressoTEEVerifierMockFilterer, error) {
+	contract, err := bindEspressoTEEVerifierMock(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierMockFilterer{contract: contract}, nil
+}
+
+// bindEspressoTEEVerifierMock binds a generic wrapper to an already deployed contract.
+func bindEspressoTEEVerifierMock(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := EspressoTEEVerifierMockMetaData.GetAbi()
+	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 (_EspressoTEEVerifierMock *EspressoTEEVerifierMockRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoTEEVerifierMock.Contract.EspressoTEEVerifierMockCaller.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 (_EspressoTEEVerifierMock *EspressoTEEVerifierMockRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierMock.Contract.EspressoTEEVerifierMockTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoTEEVerifierMock.Contract.EspressoTEEVerifierMockTransactor.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 (_EspressoTEEVerifierMock *EspressoTEEVerifierMockCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoTEEVerifierMock.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 (_EspressoTEEVerifierMock *EspressoTEEVerifierMockTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierMock.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoTEEVerifierMock.Contract.contract.Transact(opts, method, params...)
+}
+
+// RegisteredSigner is a free data retrieval call binding the contract method 0xdefc69ec.
+//
+// Solidity: function registeredSigner(address ) view returns(bool)
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockCaller) RegisteredSigner(opts *bind.CallOpts, arg0 common.Address) (bool, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierMock.contract.Call(opts, &out, "registeredSigner", arg0)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredSigner is a free data retrieval call binding the contract method 0xdefc69ec.
+//
+// Solidity: function registeredSigner(address ) view returns(bool)
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockSession) RegisteredSigner(arg0 common.Address) (bool, error) {
+	return _EspressoTEEVerifierMock.Contract.RegisteredSigner(&_EspressoTEEVerifierMock.CallOpts, arg0)
+}
+
+// RegisteredSigner is a free data retrieval call binding the contract method 0xdefc69ec.
+//
+// Solidity: function registeredSigner(address ) view returns(bool)
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockCallerSession) RegisteredSigner(arg0 common.Address) (bool, error) {
+	return _EspressoTEEVerifierMock.Contract.RegisteredSigner(&_EspressoTEEVerifierMock.CallOpts, arg0)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0xe9b1a7be.
+//
+// Solidity: function registeredSigners(address signer, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockCaller) RegisteredSigners(opts *bind.CallOpts, signer common.Address, teeType uint8) (bool, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierMock.contract.Call(opts, &out, "registeredSigners", signer, teeType)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0xe9b1a7be.
+//
+// Solidity: function registeredSigners(address signer, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockSession) RegisteredSigners(signer common.Address, teeType uint8) (bool, error) {
+	return _EspressoTEEVerifierMock.Contract.RegisteredSigners(&_EspressoTEEVerifierMock.CallOpts, signer, teeType)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0xe9b1a7be.
+//
+// Solidity: function registeredSigners(address signer, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockCallerSession) RegisteredSigners(signer common.Address, teeType uint8) (bool, error) {
+	return _EspressoTEEVerifierMock.Contract.RegisteredSigners(&_EspressoTEEVerifierMock.CallOpts, signer, teeType)
+}
+
+// Verify is a free data retrieval call binding the contract method 0xa81d9c5c.
+//
+// Solidity: function verify(bytes signature, bytes32 userDataHash, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockCaller) Verify(opts *bind.CallOpts, signature []byte, userDataHash [32]byte, teeType uint8) (bool, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierMock.contract.Call(opts, &out, "verify", signature, userDataHash, teeType)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// Verify is a free data retrieval call binding the contract method 0xa81d9c5c.
+//
+// Solidity: function verify(bytes signature, bytes32 userDataHash, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockSession) Verify(signature []byte, userDataHash [32]byte, teeType uint8) (bool, error) {
+	return _EspressoTEEVerifierMock.Contract.Verify(&_EspressoTEEVerifierMock.CallOpts, signature, userDataHash, teeType)
+}
+
+// Verify is a free data retrieval call binding the contract method 0xa81d9c5c.
+//
+// Solidity: function verify(bytes signature, bytes32 userDataHash, uint8 teeType) view returns(bool)
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockCallerSession) Verify(signature []byte, userDataHash [32]byte, teeType uint8) (bool, error) {
+	return _EspressoTEEVerifierMock.Contract.Verify(&_EspressoTEEVerifierMock.CallOpts, signature, userDataHash, teeType)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0x35ecb4c1.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data, uint8 teeType) returns()
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockTransactor) RegisterSigner(opts *bind.TransactOpts, attestation []byte, data []byte, teeType uint8) (*types.Transaction, error) {
+	return _EspressoTEEVerifierMock.contract.Transact(opts, "registerSigner", attestation, data, teeType)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0x35ecb4c1.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data, uint8 teeType) returns()
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockSession) RegisterSigner(attestation []byte, data []byte, teeType uint8) (*types.Transaction, error) {
+	return _EspressoTEEVerifierMock.Contract.RegisterSigner(&_EspressoTEEVerifierMock.TransactOpts, attestation, data, teeType)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0x35ecb4c1.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data, uint8 teeType) returns()
+func (_EspressoTEEVerifierMock *EspressoTEEVerifierMockTransactorSession) RegisterSigner(attestation []byte, data []byte, teeType uint8) (*types.Transaction, error) {
+	return _EspressoTEEVerifierMock.Contract.RegisterSigner(&_EspressoTEEVerifierMock.TransactOpts, attestation, data, teeType)
+}
+
+// EspressoTEEVerifierTestMetaData contains all meta data concerning the EspressoTEEVerifierTest contract.
+var EspressoTEEVerifierTestMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testAddressRetrievalNitro\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testAddressRetrievalSGX\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testEspressoNitroTEEVerifySignature\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testNitroRegisterSigner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testNitroRegisterSignerInvalidPCR0Hash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testNitroRegisteredEnclaveHash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testNitroRegisteredSigners\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testOwnershipTransfer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testSGXRegisterSigner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testSGXRegisterSignerWithInvalidQuote\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testSGXRegisteredEnclaveHash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testSGXRegisteredSigners\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testSetEspressoNitroTEEVerifier\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testSetEspressoSGXTEEVerifier\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"}]",
+	Bin: "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",
+}
+
+// EspressoTEEVerifierTestABI is the input ABI used to generate the binding from.
+// Deprecated: Use EspressoTEEVerifierTestMetaData.ABI instead.
+var EspressoTEEVerifierTestABI = EspressoTEEVerifierTestMetaData.ABI
+
+// EspressoTEEVerifierTestBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use EspressoTEEVerifierTestMetaData.Bin instead.
+var EspressoTEEVerifierTestBin = EspressoTEEVerifierTestMetaData.Bin
+
+// DeployEspressoTEEVerifierTest deploys a new Ethereum contract, binding an instance of EspressoTEEVerifierTest to it.
+func DeployEspressoTEEVerifierTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *EspressoTEEVerifierTest, error) {
+	parsed, err := EspressoTEEVerifierTestMetaData.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(EspressoTEEVerifierTestBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &EspressoTEEVerifierTest{EspressoTEEVerifierTestCaller: EspressoTEEVerifierTestCaller{contract: contract}, EspressoTEEVerifierTestTransactor: EspressoTEEVerifierTestTransactor{contract: contract}, EspressoTEEVerifierTestFilterer: EspressoTEEVerifierTestFilterer{contract: contract}}, nil
+}
+
+// EspressoTEEVerifierTest is an auto generated Go binding around an Ethereum contract.
+type EspressoTEEVerifierTest struct {
+	EspressoTEEVerifierTestCaller     // Read-only binding to the contract
+	EspressoTEEVerifierTestTransactor // Write-only binding to the contract
+	EspressoTEEVerifierTestFilterer   // Log filterer for contract events
+}
+
+// EspressoTEEVerifierTestCaller is an auto generated read-only Go binding around an Ethereum contract.
+type EspressoTEEVerifierTestCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoTEEVerifierTestTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type EspressoTEEVerifierTestTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoTEEVerifierTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type EspressoTEEVerifierTestFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// EspressoTEEVerifierTestSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type EspressoTEEVerifierTestSession struct {
+	Contract     *EspressoTEEVerifierTest // 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
+}
+
+// EspressoTEEVerifierTestCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type EspressoTEEVerifierTestCallerSession struct {
+	Contract *EspressoTEEVerifierTestCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts                  // Call options to use throughout this session
+}
+
+// EspressoTEEVerifierTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type EspressoTEEVerifierTestTransactorSession struct {
+	Contract     *EspressoTEEVerifierTestTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts                  // Transaction auth options to use throughout this session
+}
+
+// EspressoTEEVerifierTestRaw is an auto generated low-level Go binding around an Ethereum contract.
+type EspressoTEEVerifierTestRaw struct {
+	Contract *EspressoTEEVerifierTest // Generic contract binding to access the raw methods on
+}
+
+// EspressoTEEVerifierTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type EspressoTEEVerifierTestCallerRaw struct {
+	Contract *EspressoTEEVerifierTestCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// EspressoTEEVerifierTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type EspressoTEEVerifierTestTransactorRaw struct {
+	Contract *EspressoTEEVerifierTestTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewEspressoTEEVerifierTest creates a new instance of EspressoTEEVerifierTest, bound to a specific deployed contract.
+func NewEspressoTEEVerifierTest(address common.Address, backend bind.ContractBackend) (*EspressoTEEVerifierTest, error) {
+	contract, err := bindEspressoTEEVerifierTest(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTest{EspressoTEEVerifierTestCaller: EspressoTEEVerifierTestCaller{contract: contract}, EspressoTEEVerifierTestTransactor: EspressoTEEVerifierTestTransactor{contract: contract}, EspressoTEEVerifierTestFilterer: EspressoTEEVerifierTestFilterer{contract: contract}}, nil
+}
+
+// NewEspressoTEEVerifierTestCaller creates a new read-only instance of EspressoTEEVerifierTest, bound to a specific deployed contract.
+func NewEspressoTEEVerifierTestCaller(address common.Address, caller bind.ContractCaller) (*EspressoTEEVerifierTestCaller, error) {
+	contract, err := bindEspressoTEEVerifierTest(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestCaller{contract: contract}, nil
+}
+
+// NewEspressoTEEVerifierTestTransactor creates a new write-only instance of EspressoTEEVerifierTest, bound to a specific deployed contract.
+func NewEspressoTEEVerifierTestTransactor(address common.Address, transactor bind.ContractTransactor) (*EspressoTEEVerifierTestTransactor, error) {
+	contract, err := bindEspressoTEEVerifierTest(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestTransactor{contract: contract}, nil
+}
+
+// NewEspressoTEEVerifierTestFilterer creates a new log filterer instance of EspressoTEEVerifierTest, bound to a specific deployed contract.
+func NewEspressoTEEVerifierTestFilterer(address common.Address, filterer bind.ContractFilterer) (*EspressoTEEVerifierTestFilterer, error) {
+	contract, err := bindEspressoTEEVerifierTest(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestFilterer{contract: contract}, nil
+}
+
+// bindEspressoTEEVerifierTest binds a generic wrapper to an already deployed contract.
+func bindEspressoTEEVerifierTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := EspressoTEEVerifierTestMetaData.GetAbi()
+	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 (_EspressoTEEVerifierTest *EspressoTEEVerifierTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoTEEVerifierTest.Contract.EspressoTEEVerifierTestCaller.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 (_EspressoTEEVerifierTest *EspressoTEEVerifierTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.EspressoTEEVerifierTestTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.EspressoTEEVerifierTestTransactor.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 (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _EspressoTEEVerifierTest.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 (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.contract.Transact(opts, method, params...)
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCaller) ISTEST(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierTest.contract.Call(opts, &out, "IS_TEST")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) ISTEST() (bool, error) {
+	return _EspressoTEEVerifierTest.Contract.ISTEST(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCallerSession) ISTEST() (bool, error) {
+	return _EspressoTEEVerifierTest.Contract.ISTEST(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCaller) ExcludeArtifacts(opts *bind.CallOpts) ([]string, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierTest.contract.Call(opts, &out, "excludeArtifacts")
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) ExcludeArtifacts() ([]string, error) {
+	return _EspressoTEEVerifierTest.Contract.ExcludeArtifacts(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCallerSession) ExcludeArtifacts() ([]string, error) {
+	return _EspressoTEEVerifierTest.Contract.ExcludeArtifacts(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCaller) ExcludeContracts(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierTest.contract.Call(opts, &out, "excludeContracts")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) ExcludeContracts() ([]common.Address, error) {
+	return _EspressoTEEVerifierTest.Contract.ExcludeContracts(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCallerSession) ExcludeContracts() ([]common.Address, error) {
+	return _EspressoTEEVerifierTest.Contract.ExcludeContracts(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCaller) ExcludeSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierTest.contract.Call(opts, &out, "excludeSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector)
+
+	return out0, err
+
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoTEEVerifierTest.Contract.ExcludeSelectors(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCallerSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoTEEVerifierTest.Contract.ExcludeSelectors(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCaller) ExcludeSenders(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierTest.contract.Call(opts, &out, "excludeSenders")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) ExcludeSenders() ([]common.Address, error) {
+	return _EspressoTEEVerifierTest.Contract.ExcludeSenders(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCallerSession) ExcludeSenders() ([]common.Address, error) {
+	return _EspressoTEEVerifierTest.Contract.ExcludeSenders(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCaller) Failed(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierTest.contract.Call(opts, &out, "failed")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) Failed() (bool, error) {
+	return _EspressoTEEVerifierTest.Contract.Failed(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCallerSession) Failed() (bool, error) {
+	return _EspressoTEEVerifierTest.Contract.Failed(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCaller) TargetArtifactSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzArtifactSelector, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierTest.contract.Call(opts, &out, "targetArtifactSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzArtifactSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzArtifactSelector)).(*[]StdInvariantFuzzArtifactSelector)
+
+	return out0, err
+
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) {
+	return _EspressoTEEVerifierTest.Contract.TargetArtifactSelectors(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCallerSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) {
+	return _EspressoTEEVerifierTest.Contract.TargetArtifactSelectors(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCaller) TargetArtifacts(opts *bind.CallOpts) ([]string, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierTest.contract.Call(opts, &out, "targetArtifacts")
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TargetArtifacts() ([]string, error) {
+	return _EspressoTEEVerifierTest.Contract.TargetArtifacts(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCallerSession) TargetArtifacts() ([]string, error) {
+	return _EspressoTEEVerifierTest.Contract.TargetArtifacts(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCaller) TargetContracts(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierTest.contract.Call(opts, &out, "targetContracts")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TargetContracts() ([]common.Address, error) {
+	return _EspressoTEEVerifierTest.Contract.TargetContracts(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCallerSession) TargetContracts() ([]common.Address, error) {
+	return _EspressoTEEVerifierTest.Contract.TargetContracts(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCaller) TargetInterfaces(opts *bind.CallOpts) ([]StdInvariantFuzzInterface, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierTest.contract.Call(opts, &out, "targetInterfaces")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzInterface), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzInterface)).(*[]StdInvariantFuzzInterface)
+
+	return out0, err
+
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) {
+	return _EspressoTEEVerifierTest.Contract.TargetInterfaces(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCallerSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) {
+	return _EspressoTEEVerifierTest.Contract.TargetInterfaces(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCaller) TargetSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierTest.contract.Call(opts, &out, "targetSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector)
+
+	return out0, err
+
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoTEEVerifierTest.Contract.TargetSelectors(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCallerSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _EspressoTEEVerifierTest.Contract.TargetSelectors(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCaller) TargetSenders(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _EspressoTEEVerifierTest.contract.Call(opts, &out, "targetSenders")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TargetSenders() ([]common.Address, error) {
+	return _EspressoTEEVerifierTest.Contract.TargetSenders(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestCallerSession) TargetSenders() ([]common.Address, error) {
+	return _EspressoTEEVerifierTest.Contract.TargetSenders(&_EspressoTEEVerifierTest.CallOpts)
+}
+
+// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4.
+//
+// Solidity: function setUp() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) SetUp(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "setUp")
+}
+
+// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4.
+//
+// Solidity: function setUp() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) SetUp() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.SetUp(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4.
+//
+// Solidity: function setUp() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) SetUp() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.SetUp(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestAddressRetrievalNitro is a paid mutator transaction binding the contract method 0x68433a09.
+//
+// Solidity: function testAddressRetrievalNitro() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestAddressRetrievalNitro(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testAddressRetrievalNitro")
+}
+
+// TestAddressRetrievalNitro is a paid mutator transaction binding the contract method 0x68433a09.
+//
+// Solidity: function testAddressRetrievalNitro() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestAddressRetrievalNitro() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestAddressRetrievalNitro(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestAddressRetrievalNitro is a paid mutator transaction binding the contract method 0x68433a09.
+//
+// Solidity: function testAddressRetrievalNitro() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestAddressRetrievalNitro() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestAddressRetrievalNitro(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestAddressRetrievalSGX is a paid mutator transaction binding the contract method 0xe4004380.
+//
+// Solidity: function testAddressRetrievalSGX() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestAddressRetrievalSGX(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testAddressRetrievalSGX")
+}
+
+// TestAddressRetrievalSGX is a paid mutator transaction binding the contract method 0xe4004380.
+//
+// Solidity: function testAddressRetrievalSGX() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestAddressRetrievalSGX() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestAddressRetrievalSGX(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestAddressRetrievalSGX is a paid mutator transaction binding the contract method 0xe4004380.
+//
+// Solidity: function testAddressRetrievalSGX() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestAddressRetrievalSGX() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestAddressRetrievalSGX(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestEspressoNitroTEEVerifySignature is a paid mutator transaction binding the contract method 0x68b2a35b.
+//
+// Solidity: function testEspressoNitroTEEVerifySignature() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestEspressoNitroTEEVerifySignature(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testEspressoNitroTEEVerifySignature")
+}
+
+// TestEspressoNitroTEEVerifySignature is a paid mutator transaction binding the contract method 0x68b2a35b.
+//
+// Solidity: function testEspressoNitroTEEVerifySignature() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestEspressoNitroTEEVerifySignature() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestEspressoNitroTEEVerifySignature(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestEspressoNitroTEEVerifySignature is a paid mutator transaction binding the contract method 0x68b2a35b.
+//
+// Solidity: function testEspressoNitroTEEVerifySignature() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestEspressoNitroTEEVerifySignature() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestEspressoNitroTEEVerifySignature(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestNitroRegisterSigner is a paid mutator transaction binding the contract method 0x5e7527fd.
+//
+// Solidity: function testNitroRegisterSigner() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestNitroRegisterSigner(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testNitroRegisterSigner")
+}
+
+// TestNitroRegisterSigner is a paid mutator transaction binding the contract method 0x5e7527fd.
+//
+// Solidity: function testNitroRegisterSigner() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestNitroRegisterSigner() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestNitroRegisterSigner(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestNitroRegisterSigner is a paid mutator transaction binding the contract method 0x5e7527fd.
+//
+// Solidity: function testNitroRegisterSigner() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestNitroRegisterSigner() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestNitroRegisterSigner(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestNitroRegisterSignerInvalidPCR0Hash is a paid mutator transaction binding the contract method 0xe1a2c76d.
+//
+// Solidity: function testNitroRegisterSignerInvalidPCR0Hash() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestNitroRegisterSignerInvalidPCR0Hash(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testNitroRegisterSignerInvalidPCR0Hash")
+}
+
+// TestNitroRegisterSignerInvalidPCR0Hash is a paid mutator transaction binding the contract method 0xe1a2c76d.
+//
+// Solidity: function testNitroRegisterSignerInvalidPCR0Hash() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestNitroRegisterSignerInvalidPCR0Hash() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestNitroRegisterSignerInvalidPCR0Hash(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestNitroRegisterSignerInvalidPCR0Hash is a paid mutator transaction binding the contract method 0xe1a2c76d.
+//
+// Solidity: function testNitroRegisterSignerInvalidPCR0Hash() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestNitroRegisterSignerInvalidPCR0Hash() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestNitroRegisterSignerInvalidPCR0Hash(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestNitroRegisteredEnclaveHash is a paid mutator transaction binding the contract method 0xb5116564.
+//
+// Solidity: function testNitroRegisteredEnclaveHash() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestNitroRegisteredEnclaveHash(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testNitroRegisteredEnclaveHash")
+}
+
+// TestNitroRegisteredEnclaveHash is a paid mutator transaction binding the contract method 0xb5116564.
+//
+// Solidity: function testNitroRegisteredEnclaveHash() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestNitroRegisteredEnclaveHash() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestNitroRegisteredEnclaveHash(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestNitroRegisteredEnclaveHash is a paid mutator transaction binding the contract method 0xb5116564.
+//
+// Solidity: function testNitroRegisteredEnclaveHash() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestNitroRegisteredEnclaveHash() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestNitroRegisteredEnclaveHash(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestNitroRegisteredSigners is a paid mutator transaction binding the contract method 0x6cacda60.
+//
+// Solidity: function testNitroRegisteredSigners() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestNitroRegisteredSigners(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testNitroRegisteredSigners")
+}
+
+// TestNitroRegisteredSigners is a paid mutator transaction binding the contract method 0x6cacda60.
+//
+// Solidity: function testNitroRegisteredSigners() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestNitroRegisteredSigners() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestNitroRegisteredSigners(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestNitroRegisteredSigners is a paid mutator transaction binding the contract method 0x6cacda60.
+//
+// Solidity: function testNitroRegisteredSigners() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestNitroRegisteredSigners() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestNitroRegisteredSigners(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestOwnershipTransfer is a paid mutator transaction binding the contract method 0x575fc5d5.
+//
+// Solidity: function testOwnershipTransfer() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestOwnershipTransfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testOwnershipTransfer")
+}
+
+// TestOwnershipTransfer is a paid mutator transaction binding the contract method 0x575fc5d5.
+//
+// Solidity: function testOwnershipTransfer() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestOwnershipTransfer() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestOwnershipTransfer(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestOwnershipTransfer is a paid mutator transaction binding the contract method 0x575fc5d5.
+//
+// Solidity: function testOwnershipTransfer() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestOwnershipTransfer() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestOwnershipTransfer(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestSGXRegisterSigner is a paid mutator transaction binding the contract method 0xeb2c0e95.
+//
+// Solidity: function testSGXRegisterSigner() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestSGXRegisterSigner(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testSGXRegisterSigner")
+}
+
+// TestSGXRegisterSigner is a paid mutator transaction binding the contract method 0xeb2c0e95.
+//
+// Solidity: function testSGXRegisterSigner() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestSGXRegisterSigner() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestSGXRegisterSigner(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestSGXRegisterSigner is a paid mutator transaction binding the contract method 0xeb2c0e95.
+//
+// Solidity: function testSGXRegisterSigner() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestSGXRegisterSigner() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestSGXRegisterSigner(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestSGXRegisterSignerWithInvalidQuote is a paid mutator transaction binding the contract method 0x7903c7ca.
+//
+// Solidity: function testSGXRegisterSignerWithInvalidQuote() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestSGXRegisterSignerWithInvalidQuote(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testSGXRegisterSignerWithInvalidQuote")
+}
+
+// TestSGXRegisterSignerWithInvalidQuote is a paid mutator transaction binding the contract method 0x7903c7ca.
+//
+// Solidity: function testSGXRegisterSignerWithInvalidQuote() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestSGXRegisterSignerWithInvalidQuote() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestSGXRegisterSignerWithInvalidQuote(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestSGXRegisterSignerWithInvalidQuote is a paid mutator transaction binding the contract method 0x7903c7ca.
+//
+// Solidity: function testSGXRegisterSignerWithInvalidQuote() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestSGXRegisterSignerWithInvalidQuote() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestSGXRegisterSignerWithInvalidQuote(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestSGXRegisteredEnclaveHash is a paid mutator transaction binding the contract method 0xfd761031.
+//
+// Solidity: function testSGXRegisteredEnclaveHash() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestSGXRegisteredEnclaveHash(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testSGXRegisteredEnclaveHash")
+}
+
+// TestSGXRegisteredEnclaveHash is a paid mutator transaction binding the contract method 0xfd761031.
+//
+// Solidity: function testSGXRegisteredEnclaveHash() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestSGXRegisteredEnclaveHash() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestSGXRegisteredEnclaveHash(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestSGXRegisteredEnclaveHash is a paid mutator transaction binding the contract method 0xfd761031.
+//
+// Solidity: function testSGXRegisteredEnclaveHash() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestSGXRegisteredEnclaveHash() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestSGXRegisteredEnclaveHash(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestSGXRegisteredSigners is a paid mutator transaction binding the contract method 0x309766e1.
+//
+// Solidity: function testSGXRegisteredSigners() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestSGXRegisteredSigners(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testSGXRegisteredSigners")
+}
+
+// TestSGXRegisteredSigners is a paid mutator transaction binding the contract method 0x309766e1.
+//
+// Solidity: function testSGXRegisteredSigners() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestSGXRegisteredSigners() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestSGXRegisteredSigners(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestSGXRegisteredSigners is a paid mutator transaction binding the contract method 0x309766e1.
+//
+// Solidity: function testSGXRegisteredSigners() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestSGXRegisteredSigners() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestSGXRegisteredSigners(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestSetEspressoNitroTEEVerifier is a paid mutator transaction binding the contract method 0xcf67dea8.
+//
+// Solidity: function testSetEspressoNitroTEEVerifier() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestSetEspressoNitroTEEVerifier(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testSetEspressoNitroTEEVerifier")
+}
+
+// TestSetEspressoNitroTEEVerifier is a paid mutator transaction binding the contract method 0xcf67dea8.
+//
+// Solidity: function testSetEspressoNitroTEEVerifier() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestSetEspressoNitroTEEVerifier() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestSetEspressoNitroTEEVerifier(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestSetEspressoNitroTEEVerifier is a paid mutator transaction binding the contract method 0xcf67dea8.
+//
+// Solidity: function testSetEspressoNitroTEEVerifier() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestSetEspressoNitroTEEVerifier() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestSetEspressoNitroTEEVerifier(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestSetEspressoSGXTEEVerifier is a paid mutator transaction binding the contract method 0xdcee4fba.
+//
+// Solidity: function testSetEspressoSGXTEEVerifier() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactor) TestSetEspressoSGXTEEVerifier(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.contract.Transact(opts, "testSetEspressoSGXTEEVerifier")
+}
+
+// TestSetEspressoSGXTEEVerifier is a paid mutator transaction binding the contract method 0xdcee4fba.
+//
+// Solidity: function testSetEspressoSGXTEEVerifier() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestSession) TestSetEspressoSGXTEEVerifier() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestSetEspressoSGXTEEVerifier(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// TestSetEspressoSGXTEEVerifier is a paid mutator transaction binding the contract method 0xdcee4fba.
+//
+// Solidity: function testSetEspressoSGXTEEVerifier() returns()
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestTransactorSession) TestSetEspressoSGXTEEVerifier() (*types.Transaction, error) {
+	return _EspressoTEEVerifierTest.Contract.TestSetEspressoSGXTEEVerifier(&_EspressoTEEVerifierTest.TransactOpts)
+}
+
+// EspressoTEEVerifierTestLogIterator is returned from FilterLog and is used to iterate over the raw logs and unpacked data for Log events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogIterator struct {
+	Event *EspressoTEEVerifierTestLog // 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 *EspressoTEEVerifierTestLogIterator) 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(EspressoTEEVerifierTestLog)
+			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(EspressoTEEVerifierTestLog)
+		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 *EspressoTEEVerifierTestLogIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLog represents a Log event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLog struct {
+	Arg0 string
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLog is a free log retrieval operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLog(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogIterator{contract: _EspressoTEEVerifierTest.contract, event: "log", logs: logs, sub: sub}, nil
+}
+
+// WatchLog is a free log subscription operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLog(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLog) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log")
+	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(EspressoTEEVerifierTestLog)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log", 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
+}
+
+// ParseLog is a log parse operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLog(log types.Log) (*EspressoTEEVerifierTestLog, error) {
+	event := new(EspressoTEEVerifierTestLog)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogAddressIterator is returned from FilterLogAddress and is used to iterate over the raw logs and unpacked data for LogAddress events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogAddressIterator struct {
+	Event *EspressoTEEVerifierTestLogAddress // 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 *EspressoTEEVerifierTestLogAddressIterator) 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(EspressoTEEVerifierTestLogAddress)
+			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(EspressoTEEVerifierTestLogAddress)
+		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 *EspressoTEEVerifierTestLogAddressIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogAddressIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogAddress represents a LogAddress event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogAddress struct {
+	Arg0 common.Address
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogAddress is a free log retrieval operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogAddress(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogAddressIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_address")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogAddressIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_address", logs: logs, sub: sub}, nil
+}
+
+// WatchLogAddress is a free log subscription operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogAddress(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogAddress) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_address")
+	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(EspressoTEEVerifierTestLogAddress)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_address", 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
+}
+
+// ParseLogAddress is a log parse operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogAddress(log types.Log) (*EspressoTEEVerifierTestLogAddress, error) {
+	event := new(EspressoTEEVerifierTestLogAddress)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_address", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogArrayIterator is returned from FilterLogArray and is used to iterate over the raw logs and unpacked data for LogArray events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogArrayIterator struct {
+	Event *EspressoTEEVerifierTestLogArray // 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 *EspressoTEEVerifierTestLogArrayIterator) 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(EspressoTEEVerifierTestLogArray)
+			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(EspressoTEEVerifierTestLogArray)
+		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 *EspressoTEEVerifierTestLogArrayIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogArrayIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogArray represents a LogArray event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogArray struct {
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray is a free log retrieval operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogArray(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogArrayIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_array")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogArrayIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_array", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray is a free log subscription operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogArray(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogArray) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_array")
+	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(EspressoTEEVerifierTestLogArray)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_array", 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
+}
+
+// ParseLogArray is a log parse operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogArray(log types.Log) (*EspressoTEEVerifierTestLogArray, error) {
+	event := new(EspressoTEEVerifierTestLogArray)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_array", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogArray0Iterator is returned from FilterLogArray0 and is used to iterate over the raw logs and unpacked data for LogArray0 events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogArray0Iterator struct {
+	Event *EspressoTEEVerifierTestLogArray0 // 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 *EspressoTEEVerifierTestLogArray0Iterator) 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(EspressoTEEVerifierTestLogArray0)
+			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(EspressoTEEVerifierTestLogArray0)
+		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 *EspressoTEEVerifierTestLogArray0Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogArray0Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogArray0 represents a LogArray0 event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogArray0 struct {
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray0 is a free log retrieval operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogArray0(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogArray0Iterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_array0")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogArray0Iterator{contract: _EspressoTEEVerifierTest.contract, event: "log_array0", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray0 is a free log subscription operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogArray0(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogArray0) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_array0")
+	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(EspressoTEEVerifierTestLogArray0)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_array0", 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
+}
+
+// ParseLogArray0 is a log parse operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogArray0(log types.Log) (*EspressoTEEVerifierTestLogArray0, error) {
+	event := new(EspressoTEEVerifierTestLogArray0)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_array0", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogArray1Iterator is returned from FilterLogArray1 and is used to iterate over the raw logs and unpacked data for LogArray1 events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogArray1Iterator struct {
+	Event *EspressoTEEVerifierTestLogArray1 // 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 *EspressoTEEVerifierTestLogArray1Iterator) 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(EspressoTEEVerifierTestLogArray1)
+			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(EspressoTEEVerifierTestLogArray1)
+		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 *EspressoTEEVerifierTestLogArray1Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogArray1Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogArray1 represents a LogArray1 event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogArray1 struct {
+	Val []common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray1 is a free log retrieval operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogArray1(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogArray1Iterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_array1")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogArray1Iterator{contract: _EspressoTEEVerifierTest.contract, event: "log_array1", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray1 is a free log subscription operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogArray1(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogArray1) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_array1")
+	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(EspressoTEEVerifierTestLogArray1)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_array1", 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
+}
+
+// ParseLogArray1 is a log parse operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogArray1(log types.Log) (*EspressoTEEVerifierTestLogArray1, error) {
+	event := new(EspressoTEEVerifierTestLogArray1)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_array1", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogBytesIterator is returned from FilterLogBytes and is used to iterate over the raw logs and unpacked data for LogBytes events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogBytesIterator struct {
+	Event *EspressoTEEVerifierTestLogBytes // 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 *EspressoTEEVerifierTestLogBytesIterator) 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(EspressoTEEVerifierTestLogBytes)
+			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(EspressoTEEVerifierTestLogBytes)
+		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 *EspressoTEEVerifierTestLogBytesIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogBytesIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogBytes represents a LogBytes event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogBytes struct {
+	Arg0 []byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogBytes is a free log retrieval operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogBytes(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogBytesIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_bytes")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogBytesIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_bytes", logs: logs, sub: sub}, nil
+}
+
+// WatchLogBytes is a free log subscription operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogBytes(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogBytes) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_bytes")
+	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(EspressoTEEVerifierTestLogBytes)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_bytes", 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
+}
+
+// ParseLogBytes is a log parse operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogBytes(log types.Log) (*EspressoTEEVerifierTestLogBytes, error) {
+	event := new(EspressoTEEVerifierTestLogBytes)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_bytes", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogBytes32Iterator is returned from FilterLogBytes32 and is used to iterate over the raw logs and unpacked data for LogBytes32 events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogBytes32Iterator struct {
+	Event *EspressoTEEVerifierTestLogBytes32 // 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 *EspressoTEEVerifierTestLogBytes32Iterator) 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(EspressoTEEVerifierTestLogBytes32)
+			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(EspressoTEEVerifierTestLogBytes32)
+		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 *EspressoTEEVerifierTestLogBytes32Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogBytes32Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogBytes32 represents a LogBytes32 event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogBytes32 struct {
+	Arg0 [32]byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogBytes32 is a free log retrieval operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogBytes32(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogBytes32Iterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_bytes32")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogBytes32Iterator{contract: _EspressoTEEVerifierTest.contract, event: "log_bytes32", logs: logs, sub: sub}, nil
+}
+
+// WatchLogBytes32 is a free log subscription operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogBytes32(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogBytes32) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_bytes32")
+	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(EspressoTEEVerifierTestLogBytes32)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_bytes32", 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
+}
+
+// ParseLogBytes32 is a log parse operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogBytes32(log types.Log) (*EspressoTEEVerifierTestLogBytes32, error) {
+	event := new(EspressoTEEVerifierTestLogBytes32)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_bytes32", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogIntIterator is returned from FilterLogInt and is used to iterate over the raw logs and unpacked data for LogInt events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogIntIterator struct {
+	Event *EspressoTEEVerifierTestLogInt // 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 *EspressoTEEVerifierTestLogIntIterator) 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(EspressoTEEVerifierTestLogInt)
+			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(EspressoTEEVerifierTestLogInt)
+		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 *EspressoTEEVerifierTestLogIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogInt represents a LogInt event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogInt struct {
+	Arg0 *big.Int
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogInt is a free log retrieval operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogInt(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogIntIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_int")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogIntIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogInt is a free log subscription operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogInt(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogInt) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_int")
+	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(EspressoTEEVerifierTestLogInt)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_int", 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
+}
+
+// ParseLogInt is a log parse operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogInt(log types.Log) (*EspressoTEEVerifierTestLogInt, error) {
+	event := new(EspressoTEEVerifierTestLogInt)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogNamedAddressIterator is returned from FilterLogNamedAddress and is used to iterate over the raw logs and unpacked data for LogNamedAddress events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedAddressIterator struct {
+	Event *EspressoTEEVerifierTestLogNamedAddress // 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 *EspressoTEEVerifierTestLogNamedAddressIterator) 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(EspressoTEEVerifierTestLogNamedAddress)
+			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(EspressoTEEVerifierTestLogNamedAddress)
+		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 *EspressoTEEVerifierTestLogNamedAddressIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogNamedAddressIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogNamedAddress represents a LogNamedAddress event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedAddress struct {
+	Key string
+	Val common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedAddress is a free log retrieval operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogNamedAddress(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogNamedAddressIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_named_address")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogNamedAddressIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_named_address", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedAddress is a free log subscription operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogNamedAddress(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogNamedAddress) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_named_address")
+	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(EspressoTEEVerifierTestLogNamedAddress)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_address", 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
+}
+
+// ParseLogNamedAddress is a log parse operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogNamedAddress(log types.Log) (*EspressoTEEVerifierTestLogNamedAddress, error) {
+	event := new(EspressoTEEVerifierTestLogNamedAddress)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_address", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogNamedArrayIterator is returned from FilterLogNamedArray and is used to iterate over the raw logs and unpacked data for LogNamedArray events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedArrayIterator struct {
+	Event *EspressoTEEVerifierTestLogNamedArray // 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 *EspressoTEEVerifierTestLogNamedArrayIterator) 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(EspressoTEEVerifierTestLogNamedArray)
+			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(EspressoTEEVerifierTestLogNamedArray)
+		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 *EspressoTEEVerifierTestLogNamedArrayIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogNamedArrayIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogNamedArray represents a LogNamedArray event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedArray struct {
+	Key string
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray is a free log retrieval operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogNamedArray(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogNamedArrayIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_named_array")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogNamedArrayIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_named_array", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray is a free log subscription operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogNamedArray(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogNamedArray) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_named_array")
+	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(EspressoTEEVerifierTestLogNamedArray)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_array", 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
+}
+
+// ParseLogNamedArray is a log parse operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogNamedArray(log types.Log) (*EspressoTEEVerifierTestLogNamedArray, error) {
+	event := new(EspressoTEEVerifierTestLogNamedArray)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_array", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogNamedArray0Iterator is returned from FilterLogNamedArray0 and is used to iterate over the raw logs and unpacked data for LogNamedArray0 events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedArray0Iterator struct {
+	Event *EspressoTEEVerifierTestLogNamedArray0 // 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 *EspressoTEEVerifierTestLogNamedArray0Iterator) 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(EspressoTEEVerifierTestLogNamedArray0)
+			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(EspressoTEEVerifierTestLogNamedArray0)
+		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 *EspressoTEEVerifierTestLogNamedArray0Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogNamedArray0Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogNamedArray0 represents a LogNamedArray0 event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedArray0 struct {
+	Key string
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray0 is a free log retrieval operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogNamedArray0(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogNamedArray0Iterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_named_array0")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogNamedArray0Iterator{contract: _EspressoTEEVerifierTest.contract, event: "log_named_array0", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray0 is a free log subscription operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogNamedArray0(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogNamedArray0) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_named_array0")
+	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(EspressoTEEVerifierTestLogNamedArray0)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_array0", 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
+}
+
+// ParseLogNamedArray0 is a log parse operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogNamedArray0(log types.Log) (*EspressoTEEVerifierTestLogNamedArray0, error) {
+	event := new(EspressoTEEVerifierTestLogNamedArray0)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_array0", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogNamedArray1Iterator is returned from FilterLogNamedArray1 and is used to iterate over the raw logs and unpacked data for LogNamedArray1 events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedArray1Iterator struct {
+	Event *EspressoTEEVerifierTestLogNamedArray1 // 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 *EspressoTEEVerifierTestLogNamedArray1Iterator) 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(EspressoTEEVerifierTestLogNamedArray1)
+			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(EspressoTEEVerifierTestLogNamedArray1)
+		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 *EspressoTEEVerifierTestLogNamedArray1Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogNamedArray1Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogNamedArray1 represents a LogNamedArray1 event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedArray1 struct {
+	Key string
+	Val []common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray1 is a free log retrieval operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogNamedArray1(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogNamedArray1Iterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_named_array1")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogNamedArray1Iterator{contract: _EspressoTEEVerifierTest.contract, event: "log_named_array1", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray1 is a free log subscription operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogNamedArray1(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogNamedArray1) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_named_array1")
+	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(EspressoTEEVerifierTestLogNamedArray1)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_array1", 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
+}
+
+// ParseLogNamedArray1 is a log parse operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogNamedArray1(log types.Log) (*EspressoTEEVerifierTestLogNamedArray1, error) {
+	event := new(EspressoTEEVerifierTestLogNamedArray1)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_array1", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogNamedBytesIterator is returned from FilterLogNamedBytes and is used to iterate over the raw logs and unpacked data for LogNamedBytes events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedBytesIterator struct {
+	Event *EspressoTEEVerifierTestLogNamedBytes // 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 *EspressoTEEVerifierTestLogNamedBytesIterator) 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(EspressoTEEVerifierTestLogNamedBytes)
+			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(EspressoTEEVerifierTestLogNamedBytes)
+		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 *EspressoTEEVerifierTestLogNamedBytesIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogNamedBytesIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogNamedBytes represents a LogNamedBytes event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedBytes struct {
+	Key string
+	Val []byte
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedBytes is a free log retrieval operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogNamedBytes(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogNamedBytesIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_named_bytes")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogNamedBytesIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_named_bytes", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedBytes is a free log subscription operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogNamedBytes(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogNamedBytes) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_named_bytes")
+	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(EspressoTEEVerifierTestLogNamedBytes)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_bytes", 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
+}
+
+// ParseLogNamedBytes is a log parse operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogNamedBytes(log types.Log) (*EspressoTEEVerifierTestLogNamedBytes, error) {
+	event := new(EspressoTEEVerifierTestLogNamedBytes)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_bytes", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogNamedBytes32Iterator is returned from FilterLogNamedBytes32 and is used to iterate over the raw logs and unpacked data for LogNamedBytes32 events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedBytes32Iterator struct {
+	Event *EspressoTEEVerifierTestLogNamedBytes32 // 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 *EspressoTEEVerifierTestLogNamedBytes32Iterator) 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(EspressoTEEVerifierTestLogNamedBytes32)
+			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(EspressoTEEVerifierTestLogNamedBytes32)
+		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 *EspressoTEEVerifierTestLogNamedBytes32Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogNamedBytes32Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogNamedBytes32 represents a LogNamedBytes32 event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedBytes32 struct {
+	Key string
+	Val [32]byte
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedBytes32 is a free log retrieval operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogNamedBytes32(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogNamedBytes32Iterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_named_bytes32")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogNamedBytes32Iterator{contract: _EspressoTEEVerifierTest.contract, event: "log_named_bytes32", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedBytes32 is a free log subscription operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogNamedBytes32(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogNamedBytes32) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_named_bytes32")
+	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(EspressoTEEVerifierTestLogNamedBytes32)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_bytes32", 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
+}
+
+// ParseLogNamedBytes32 is a log parse operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogNamedBytes32(log types.Log) (*EspressoTEEVerifierTestLogNamedBytes32, error) {
+	event := new(EspressoTEEVerifierTestLogNamedBytes32)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_bytes32", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogNamedDecimalIntIterator is returned from FilterLogNamedDecimalInt and is used to iterate over the raw logs and unpacked data for LogNamedDecimalInt events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedDecimalIntIterator struct {
+	Event *EspressoTEEVerifierTestLogNamedDecimalInt // 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 *EspressoTEEVerifierTestLogNamedDecimalIntIterator) 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(EspressoTEEVerifierTestLogNamedDecimalInt)
+			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(EspressoTEEVerifierTestLogNamedDecimalInt)
+		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 *EspressoTEEVerifierTestLogNamedDecimalIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogNamedDecimalIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogNamedDecimalInt represents a LogNamedDecimalInt event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedDecimalInt struct {
+	Key      string
+	Val      *big.Int
+	Decimals *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedDecimalInt is a free log retrieval operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogNamedDecimalInt(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogNamedDecimalIntIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_named_decimal_int")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogNamedDecimalIntIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_named_decimal_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedDecimalInt is a free log subscription operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogNamedDecimalInt(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogNamedDecimalInt) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_named_decimal_int")
+	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(EspressoTEEVerifierTestLogNamedDecimalInt)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_decimal_int", 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
+}
+
+// ParseLogNamedDecimalInt is a log parse operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogNamedDecimalInt(log types.Log) (*EspressoTEEVerifierTestLogNamedDecimalInt, error) {
+	event := new(EspressoTEEVerifierTestLogNamedDecimalInt)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogNamedDecimalUintIterator is returned from FilterLogNamedDecimalUint and is used to iterate over the raw logs and unpacked data for LogNamedDecimalUint events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedDecimalUintIterator struct {
+	Event *EspressoTEEVerifierTestLogNamedDecimalUint // 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 *EspressoTEEVerifierTestLogNamedDecimalUintIterator) 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(EspressoTEEVerifierTestLogNamedDecimalUint)
+			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(EspressoTEEVerifierTestLogNamedDecimalUint)
+		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 *EspressoTEEVerifierTestLogNamedDecimalUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogNamedDecimalUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogNamedDecimalUint represents a LogNamedDecimalUint event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedDecimalUint struct {
+	Key      string
+	Val      *big.Int
+	Decimals *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedDecimalUint is a free log retrieval operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogNamedDecimalUint(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogNamedDecimalUintIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_named_decimal_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogNamedDecimalUintIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_named_decimal_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedDecimalUint is a free log subscription operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogNamedDecimalUint(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogNamedDecimalUint) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_named_decimal_uint")
+	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(EspressoTEEVerifierTestLogNamedDecimalUint)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_decimal_uint", 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
+}
+
+// ParseLogNamedDecimalUint is a log parse operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogNamedDecimalUint(log types.Log) (*EspressoTEEVerifierTestLogNamedDecimalUint, error) {
+	event := new(EspressoTEEVerifierTestLogNamedDecimalUint)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogNamedIntIterator is returned from FilterLogNamedInt and is used to iterate over the raw logs and unpacked data for LogNamedInt events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedIntIterator struct {
+	Event *EspressoTEEVerifierTestLogNamedInt // 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 *EspressoTEEVerifierTestLogNamedIntIterator) 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(EspressoTEEVerifierTestLogNamedInt)
+			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(EspressoTEEVerifierTestLogNamedInt)
+		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 *EspressoTEEVerifierTestLogNamedIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogNamedIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogNamedInt represents a LogNamedInt event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedInt struct {
+	Key string
+	Val *big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedInt is a free log retrieval operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogNamedInt(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogNamedIntIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_named_int")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogNamedIntIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_named_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedInt is a free log subscription operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogNamedInt(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogNamedInt) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_named_int")
+	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(EspressoTEEVerifierTestLogNamedInt)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_int", 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
+}
+
+// ParseLogNamedInt is a log parse operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogNamedInt(log types.Log) (*EspressoTEEVerifierTestLogNamedInt, error) {
+	event := new(EspressoTEEVerifierTestLogNamedInt)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogNamedStringIterator is returned from FilterLogNamedString and is used to iterate over the raw logs and unpacked data for LogNamedString events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedStringIterator struct {
+	Event *EspressoTEEVerifierTestLogNamedString // 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 *EspressoTEEVerifierTestLogNamedStringIterator) 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(EspressoTEEVerifierTestLogNamedString)
+			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(EspressoTEEVerifierTestLogNamedString)
+		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 *EspressoTEEVerifierTestLogNamedStringIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogNamedStringIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogNamedString represents a LogNamedString event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedString struct {
+	Key string
+	Val string
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedString is a free log retrieval operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogNamedString(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogNamedStringIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_named_string")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogNamedStringIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_named_string", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedString is a free log subscription operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogNamedString(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogNamedString) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_named_string")
+	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(EspressoTEEVerifierTestLogNamedString)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_string", 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
+}
+
+// ParseLogNamedString is a log parse operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogNamedString(log types.Log) (*EspressoTEEVerifierTestLogNamedString, error) {
+	event := new(EspressoTEEVerifierTestLogNamedString)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_string", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogNamedUintIterator is returned from FilterLogNamedUint and is used to iterate over the raw logs and unpacked data for LogNamedUint events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedUintIterator struct {
+	Event *EspressoTEEVerifierTestLogNamedUint // 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 *EspressoTEEVerifierTestLogNamedUintIterator) 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(EspressoTEEVerifierTestLogNamedUint)
+			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(EspressoTEEVerifierTestLogNamedUint)
+		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 *EspressoTEEVerifierTestLogNamedUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogNamedUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogNamedUint represents a LogNamedUint event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogNamedUint struct {
+	Key string
+	Val *big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedUint is a free log retrieval operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogNamedUint(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogNamedUintIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_named_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogNamedUintIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_named_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedUint is a free log subscription operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogNamedUint(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogNamedUint) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_named_uint")
+	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(EspressoTEEVerifierTestLogNamedUint)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_uint", 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
+}
+
+// ParseLogNamedUint is a log parse operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogNamedUint(log types.Log) (*EspressoTEEVerifierTestLogNamedUint, error) {
+	event := new(EspressoTEEVerifierTestLogNamedUint)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_named_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogStringIterator is returned from FilterLogString and is used to iterate over the raw logs and unpacked data for LogString events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogStringIterator struct {
+	Event *EspressoTEEVerifierTestLogString // 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 *EspressoTEEVerifierTestLogStringIterator) 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(EspressoTEEVerifierTestLogString)
+			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(EspressoTEEVerifierTestLogString)
+		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 *EspressoTEEVerifierTestLogStringIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogStringIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogString represents a LogString event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogString struct {
+	Arg0 string
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogString is a free log retrieval operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogString(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogStringIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_string")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogStringIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_string", logs: logs, sub: sub}, nil
+}
+
+// WatchLogString is a free log subscription operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogString(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogString) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_string")
+	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(EspressoTEEVerifierTestLogString)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_string", 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
+}
+
+// ParseLogString is a log parse operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogString(log types.Log) (*EspressoTEEVerifierTestLogString, error) {
+	event := new(EspressoTEEVerifierTestLogString)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_string", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogUintIterator is returned from FilterLogUint and is used to iterate over the raw logs and unpacked data for LogUint events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogUintIterator struct {
+	Event *EspressoTEEVerifierTestLogUint // 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 *EspressoTEEVerifierTestLogUintIterator) 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(EspressoTEEVerifierTestLogUint)
+			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(EspressoTEEVerifierTestLogUint)
+		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 *EspressoTEEVerifierTestLogUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogUint represents a LogUint event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogUint struct {
+	Arg0 *big.Int
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogUint is a free log retrieval operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogUint(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogUintIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "log_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogUintIterator{contract: _EspressoTEEVerifierTest.contract, event: "log_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogUint is a free log subscription operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogUint(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogUint) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "log_uint")
+	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(EspressoTEEVerifierTestLogUint)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_uint", 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
+}
+
+// ParseLogUint is a log parse operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogUint(log types.Log) (*EspressoTEEVerifierTestLogUint, error) {
+	event := new(EspressoTEEVerifierTestLogUint)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "log_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// EspressoTEEVerifierTestLogsIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for Logs events raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogsIterator struct {
+	Event *EspressoTEEVerifierTestLogs // 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 *EspressoTEEVerifierTestLogsIterator) 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(EspressoTEEVerifierTestLogs)
+			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(EspressoTEEVerifierTestLogs)
+		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 *EspressoTEEVerifierTestLogsIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *EspressoTEEVerifierTestLogsIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// EspressoTEEVerifierTestLogs represents a Logs event raised by the EspressoTEEVerifierTest contract.
+type EspressoTEEVerifierTestLogs struct {
+	Arg0 []byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogs is a free log retrieval operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) FilterLogs(opts *bind.FilterOpts) (*EspressoTEEVerifierTestLogsIterator, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.FilterLogs(opts, "logs")
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoTEEVerifierTestLogsIterator{contract: _EspressoTEEVerifierTest.contract, event: "logs", logs: logs, sub: sub}, nil
+}
+
+// WatchLogs is a free log subscription operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) WatchLogs(opts *bind.WatchOpts, sink chan<- *EspressoTEEVerifierTestLogs) (event.Subscription, error) {
+
+	logs, sub, err := _EspressoTEEVerifierTest.contract.WatchLogs(opts, "logs")
+	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(EspressoTEEVerifierTestLogs)
+				if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "logs", 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
+}
+
+// ParseLogs is a log parse operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_EspressoTEEVerifierTest *EspressoTEEVerifierTestFilterer) ParseLogs(log types.Log) (*EspressoTEEVerifierTestLogs, error) {
+	event := new(EspressoTEEVerifierTestLogs)
+	if err := _EspressoTEEVerifierTest.contract.UnpackLog(event, "logs", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// FmspcTcbHelperMetaData contains all meta data concerning the FmspcTcbHelper contract.
+var FmspcTcbHelperMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"tcbInfoStr\",\"type\":\"string\"}],\"name\":\"parseTcbLevels\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"version\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"uint16\",\"name\":\"pcesvn\",\"type\":\"uint16\"},{\"internalType\":\"uint8[]\",\"name\":\"sgxComponentCpuSvns\",\"type\":\"uint8[]\"},{\"internalType\":\"uint8[]\",\"name\":\"tdxSvns\",\"type\":\"uint8[]\"},{\"internalType\":\"uint64\",\"name\":\"tcbDateTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"enumTCBStatus\",\"name\":\"status\",\"type\":\"uint8\"},{\"internalType\":\"string[]\",\"name\":\"advisoryIDs\",\"type\":\"string[]\"}],\"internalType\":\"structTCBLevelsObj[]\",\"name\":\"tcbLevels\",\"type\":\"tuple[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"tcbInfoStr\",\"type\":\"string\"}],\"name\":\"parseTcbString\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"tcbType\",\"type\":\"uint8\"},{\"internalType\":\"enumTcbId\",\"name\":\"id\",\"type\":\"uint8\"},{\"internalType\":\"uint32\",\"name\":\"version\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"issueDate\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"nextUpdate\",\"type\":\"uint64\"},{\"internalType\":\"uint32\",\"name\":\"evaluationDataNumber\",\"type\":\"uint32\"},{\"internalType\":\"bytes6\",\"name\":\"fmspc\",\"type\":\"bytes6\"},{\"internalType\":\"bytes2\",\"name\":\"pceid\",\"type\":\"bytes2\"}],\"internalType\":\"structTcbInfoBasic\",\"name\":\"tcbInfo\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"tcbInfoStr\",\"type\":\"string\"}],\"name\":\"parseTcbTdxModules\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"mrsigner\",\"type\":\"bytes\"},{\"internalType\":\"bytes8\",\"name\":\"attributes\",\"type\":\"bytes8\"},{\"internalType\":\"bytes8\",\"name\":\"attributesMask\",\"type\":\"bytes8\"}],\"internalType\":\"structTDXModule\",\"name\":\"module\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"string\",\"name\":\"id\",\"type\":\"string\"},{\"internalType\":\"bytes8\",\"name\":\"attributes\",\"type\":\"bytes8\"},{\"internalType\":\"bytes8\",\"name\":\"attributesMask\",\"type\":\"bytes8\"},{\"internalType\":\"bytes\",\"name\":\"mrsigner\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"uint8\",\"name\":\"isvsvn\",\"type\":\"uint8\"},{\"internalType\":\"uint64\",\"name\":\"tcbDateTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"enumTCBStatus\",\"name\":\"status\",\"type\":\"uint8\"}],\"internalType\":\"structTDXModuleTCBLevelsObj[]\",\"name\":\"tcbLevels\",\"type\":\"tuple[]\"}],\"internalType\":\"structTDXModuleIdentity[]\",\"name\":\"moduleIdentities\",\"type\":\"tuple[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"TCBInfo_Invalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TCB_TDX_ID_Invalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TCB_TDX_Version_Invalid\",\"type\":\"error\"}]",
+	Bin: "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",
+}
+
+// FmspcTcbHelperABI is the input ABI used to generate the binding from.
+// Deprecated: Use FmspcTcbHelperMetaData.ABI instead.
+var FmspcTcbHelperABI = FmspcTcbHelperMetaData.ABI
+
+// FmspcTcbHelperBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use FmspcTcbHelperMetaData.Bin instead.
+var FmspcTcbHelperBin = FmspcTcbHelperMetaData.Bin
+
+// DeployFmspcTcbHelper deploys a new Ethereum contract, binding an instance of FmspcTcbHelper to it.
+func DeployFmspcTcbHelper(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *FmspcTcbHelper, error) {
+	parsed, err := FmspcTcbHelperMetaData.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(FmspcTcbHelperBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &FmspcTcbHelper{FmspcTcbHelperCaller: FmspcTcbHelperCaller{contract: contract}, FmspcTcbHelperTransactor: FmspcTcbHelperTransactor{contract: contract}, FmspcTcbHelperFilterer: FmspcTcbHelperFilterer{contract: contract}}, nil
+}
+
+// FmspcTcbHelper is an auto generated Go binding around an Ethereum contract.
+type FmspcTcbHelper struct {
+	FmspcTcbHelperCaller     // Read-only binding to the contract
+	FmspcTcbHelperTransactor // Write-only binding to the contract
+	FmspcTcbHelperFilterer   // Log filterer for contract events
+}
+
+// FmspcTcbHelperCaller is an auto generated read-only Go binding around an Ethereum contract.
+type FmspcTcbHelperCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// FmspcTcbHelperTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type FmspcTcbHelperTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// FmspcTcbHelperFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type FmspcTcbHelperFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// FmspcTcbHelperSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type FmspcTcbHelperSession struct {
+	Contract     *FmspcTcbHelper   // 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
+}
+
+// FmspcTcbHelperCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type FmspcTcbHelperCallerSession struct {
+	Contract *FmspcTcbHelperCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts         // Call options to use throughout this session
+}
+
+// FmspcTcbHelperTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type FmspcTcbHelperTransactorSession struct {
+	Contract     *FmspcTcbHelperTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
+}
+
+// FmspcTcbHelperRaw is an auto generated low-level Go binding around an Ethereum contract.
+type FmspcTcbHelperRaw struct {
+	Contract *FmspcTcbHelper // Generic contract binding to access the raw methods on
+}
+
+// FmspcTcbHelperCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type FmspcTcbHelperCallerRaw struct {
+	Contract *FmspcTcbHelperCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// FmspcTcbHelperTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type FmspcTcbHelperTransactorRaw struct {
+	Contract *FmspcTcbHelperTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewFmspcTcbHelper creates a new instance of FmspcTcbHelper, bound to a specific deployed contract.
+func NewFmspcTcbHelper(address common.Address, backend bind.ContractBackend) (*FmspcTcbHelper, error) {
+	contract, err := bindFmspcTcbHelper(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &FmspcTcbHelper{FmspcTcbHelperCaller: FmspcTcbHelperCaller{contract: contract}, FmspcTcbHelperTransactor: FmspcTcbHelperTransactor{contract: contract}, FmspcTcbHelperFilterer: FmspcTcbHelperFilterer{contract: contract}}, nil
+}
+
+// NewFmspcTcbHelperCaller creates a new read-only instance of FmspcTcbHelper, bound to a specific deployed contract.
+func NewFmspcTcbHelperCaller(address common.Address, caller bind.ContractCaller) (*FmspcTcbHelperCaller, error) {
+	contract, err := bindFmspcTcbHelper(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &FmspcTcbHelperCaller{contract: contract}, nil
+}
+
+// NewFmspcTcbHelperTransactor creates a new write-only instance of FmspcTcbHelper, bound to a specific deployed contract.
+func NewFmspcTcbHelperTransactor(address common.Address, transactor bind.ContractTransactor) (*FmspcTcbHelperTransactor, error) {
+	contract, err := bindFmspcTcbHelper(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &FmspcTcbHelperTransactor{contract: contract}, nil
+}
+
+// NewFmspcTcbHelperFilterer creates a new log filterer instance of FmspcTcbHelper, bound to a specific deployed contract.
+func NewFmspcTcbHelperFilterer(address common.Address, filterer bind.ContractFilterer) (*FmspcTcbHelperFilterer, error) {
+	contract, err := bindFmspcTcbHelper(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &FmspcTcbHelperFilterer{contract: contract}, nil
+}
+
+// bindFmspcTcbHelper binds a generic wrapper to an already deployed contract.
+func bindFmspcTcbHelper(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := FmspcTcbHelperMetaData.GetAbi()
+	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 (_FmspcTcbHelper *FmspcTcbHelperRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _FmspcTcbHelper.Contract.FmspcTcbHelperCaller.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 (_FmspcTcbHelper *FmspcTcbHelperRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _FmspcTcbHelper.Contract.FmspcTcbHelperTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_FmspcTcbHelper *FmspcTcbHelperRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _FmspcTcbHelper.Contract.FmspcTcbHelperTransactor.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 (_FmspcTcbHelper *FmspcTcbHelperCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _FmspcTcbHelper.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 (_FmspcTcbHelper *FmspcTcbHelperTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _FmspcTcbHelper.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_FmspcTcbHelper *FmspcTcbHelperTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _FmspcTcbHelper.Contract.contract.Transact(opts, method, params...)
+}
+
+// ParseTcbLevels is a free data retrieval call binding the contract method 0x0985653c.
+//
+// Solidity: function parseTcbLevels(string tcbInfoStr) pure returns(uint256 version, (uint16,uint8[],uint8[],uint64,uint8,string[])[] tcbLevels)
+func (_FmspcTcbHelper *FmspcTcbHelperCaller) ParseTcbLevels(opts *bind.CallOpts, tcbInfoStr string) (struct {
+	Version   *big.Int
+	TcbLevels []TCBLevelsObj
+}, error) {
+	var out []interface{}
+	err := _FmspcTcbHelper.contract.Call(opts, &out, "parseTcbLevels", tcbInfoStr)
+
+	outstruct := new(struct {
+		Version   *big.Int
+		TcbLevels []TCBLevelsObj
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.Version = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+	outstruct.TcbLevels = *abi.ConvertType(out[1], new([]TCBLevelsObj)).(*[]TCBLevelsObj)
+
+	return *outstruct, err
+
+}
+
+// ParseTcbLevels is a free data retrieval call binding the contract method 0x0985653c.
+//
+// Solidity: function parseTcbLevels(string tcbInfoStr) pure returns(uint256 version, (uint16,uint8[],uint8[],uint64,uint8,string[])[] tcbLevels)
+func (_FmspcTcbHelper *FmspcTcbHelperSession) ParseTcbLevels(tcbInfoStr string) (struct {
+	Version   *big.Int
+	TcbLevels []TCBLevelsObj
+}, error) {
+	return _FmspcTcbHelper.Contract.ParseTcbLevels(&_FmspcTcbHelper.CallOpts, tcbInfoStr)
+}
+
+// ParseTcbLevels is a free data retrieval call binding the contract method 0x0985653c.
+//
+// Solidity: function parseTcbLevels(string tcbInfoStr) pure returns(uint256 version, (uint16,uint8[],uint8[],uint64,uint8,string[])[] tcbLevels)
+func (_FmspcTcbHelper *FmspcTcbHelperCallerSession) ParseTcbLevels(tcbInfoStr string) (struct {
+	Version   *big.Int
+	TcbLevels []TCBLevelsObj
+}, error) {
+	return _FmspcTcbHelper.Contract.ParseTcbLevels(&_FmspcTcbHelper.CallOpts, tcbInfoStr)
+}
+
+// ParseTcbString is a free data retrieval call binding the contract method 0x0f1dbf45.
+//
+// Solidity: function parseTcbString(string tcbInfoStr) pure returns((uint8,uint8,uint32,uint64,uint64,uint32,bytes6,bytes2) tcbInfo)
+func (_FmspcTcbHelper *FmspcTcbHelperCaller) ParseTcbString(opts *bind.CallOpts, tcbInfoStr string) (TcbInfoBasic, error) {
+	var out []interface{}
+	err := _FmspcTcbHelper.contract.Call(opts, &out, "parseTcbString", tcbInfoStr)
+
+	if err != nil {
+		return *new(TcbInfoBasic), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(TcbInfoBasic)).(*TcbInfoBasic)
+
+	return out0, err
+
+}
+
+// ParseTcbString is a free data retrieval call binding the contract method 0x0f1dbf45.
+//
+// Solidity: function parseTcbString(string tcbInfoStr) pure returns((uint8,uint8,uint32,uint64,uint64,uint32,bytes6,bytes2) tcbInfo)
+func (_FmspcTcbHelper *FmspcTcbHelperSession) ParseTcbString(tcbInfoStr string) (TcbInfoBasic, error) {
+	return _FmspcTcbHelper.Contract.ParseTcbString(&_FmspcTcbHelper.CallOpts, tcbInfoStr)
+}
+
+// ParseTcbString is a free data retrieval call binding the contract method 0x0f1dbf45.
+//
+// Solidity: function parseTcbString(string tcbInfoStr) pure returns((uint8,uint8,uint32,uint64,uint64,uint32,bytes6,bytes2) tcbInfo)
+func (_FmspcTcbHelper *FmspcTcbHelperCallerSession) ParseTcbString(tcbInfoStr string) (TcbInfoBasic, error) {
+	return _FmspcTcbHelper.Contract.ParseTcbString(&_FmspcTcbHelper.CallOpts, tcbInfoStr)
+}
+
+// ParseTcbTdxModules is a free data retrieval call binding the contract method 0x2793d5d2.
+//
+// Solidity: function parseTcbTdxModules(string tcbInfoStr) pure returns((bytes,bytes8,bytes8) module, (string,bytes8,bytes8,bytes,(uint8,uint64,uint8)[])[] moduleIdentities)
+func (_FmspcTcbHelper *FmspcTcbHelperCaller) ParseTcbTdxModules(opts *bind.CallOpts, tcbInfoStr string) (struct {
+	Module           TDXModule
+	ModuleIdentities []TDXModuleIdentity
+}, error) {
+	var out []interface{}
+	err := _FmspcTcbHelper.contract.Call(opts, &out, "parseTcbTdxModules", tcbInfoStr)
+
+	outstruct := new(struct {
+		Module           TDXModule
+		ModuleIdentities []TDXModuleIdentity
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.Module = *abi.ConvertType(out[0], new(TDXModule)).(*TDXModule)
+	outstruct.ModuleIdentities = *abi.ConvertType(out[1], new([]TDXModuleIdentity)).(*[]TDXModuleIdentity)
+
+	return *outstruct, err
+
+}
+
+// ParseTcbTdxModules is a free data retrieval call binding the contract method 0x2793d5d2.
+//
+// Solidity: function parseTcbTdxModules(string tcbInfoStr) pure returns((bytes,bytes8,bytes8) module, (string,bytes8,bytes8,bytes,(uint8,uint64,uint8)[])[] moduleIdentities)
+func (_FmspcTcbHelper *FmspcTcbHelperSession) ParseTcbTdxModules(tcbInfoStr string) (struct {
+	Module           TDXModule
+	ModuleIdentities []TDXModuleIdentity
+}, error) {
+	return _FmspcTcbHelper.Contract.ParseTcbTdxModules(&_FmspcTcbHelper.CallOpts, tcbInfoStr)
+}
+
+// ParseTcbTdxModules is a free data retrieval call binding the contract method 0x2793d5d2.
+//
+// Solidity: function parseTcbTdxModules(string tcbInfoStr) pure returns((bytes,bytes8,bytes8) module, (string,bytes8,bytes8,bytes,(uint8,uint64,uint8)[])[] moduleIdentities)
+func (_FmspcTcbHelper *FmspcTcbHelperCallerSession) ParseTcbTdxModules(tcbInfoStr string) (struct {
+	Module           TDXModule
+	ModuleIdentities []TDXModuleIdentity
+}, error) {
+	return _FmspcTcbHelper.Contract.ParseTcbTdxModules(&_FmspcTcbHelper.CallOpts, tcbInfoStr)
+}
+
+// ICertManagerMetaData contains all meta data concerning the ICertManager contract.
+var ICertManagerMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"cert\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"parentCertHash\",\"type\":\"bytes32\"}],\"name\":\"verifyCACert\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"cert\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"parentCertHash\",\"type\":\"bytes32\"}],\"name\":\"verifyClientCert\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"ca\",\"type\":\"bool\"},{\"internalType\":\"uint64\",\"name\":\"notAfter\",\"type\":\"uint64\"},{\"internalType\":\"int64\",\"name\":\"maxPathLen\",\"type\":\"int64\"},{\"internalType\":\"bytes32\",\"name\":\"subjectHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"pubKey\",\"type\":\"bytes\"}],\"internalType\":\"structICertManager.VerifiedCert\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
+}
+
+// ICertManagerABI is the input ABI used to generate the binding from.
+// Deprecated: Use ICertManagerMetaData.ABI instead.
+var ICertManagerABI = ICertManagerMetaData.ABI
+
+// ICertManager is an auto generated Go binding around an Ethereum contract.
+type ICertManager struct {
+	ICertManagerCaller     // Read-only binding to the contract
+	ICertManagerTransactor // Write-only binding to the contract
+	ICertManagerFilterer   // Log filterer for contract events
+}
+
+// ICertManagerCaller is an auto generated read-only Go binding around an Ethereum contract.
+type ICertManagerCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ICertManagerTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type ICertManagerTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ICertManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type ICertManagerFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ICertManagerSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type ICertManagerSession struct {
+	Contract     *ICertManager     // 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
+}
+
+// ICertManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type ICertManagerCallerSession struct {
+	Contract *ICertManagerCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts       // Call options to use throughout this session
+}
+
+// ICertManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type ICertManagerTransactorSession struct {
+	Contract     *ICertManagerTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
+}
+
+// ICertManagerRaw is an auto generated low-level Go binding around an Ethereum contract.
+type ICertManagerRaw struct {
+	Contract *ICertManager // Generic contract binding to access the raw methods on
+}
+
+// ICertManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type ICertManagerCallerRaw struct {
+	Contract *ICertManagerCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// ICertManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type ICertManagerTransactorRaw struct {
+	Contract *ICertManagerTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewICertManager creates a new instance of ICertManager, bound to a specific deployed contract.
+func NewICertManager(address common.Address, backend bind.ContractBackend) (*ICertManager, error) {
+	contract, err := bindICertManager(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &ICertManager{ICertManagerCaller: ICertManagerCaller{contract: contract}, ICertManagerTransactor: ICertManagerTransactor{contract: contract}, ICertManagerFilterer: ICertManagerFilterer{contract: contract}}, nil
+}
+
+// NewICertManagerCaller creates a new read-only instance of ICertManager, bound to a specific deployed contract.
+func NewICertManagerCaller(address common.Address, caller bind.ContractCaller) (*ICertManagerCaller, error) {
+	contract, err := bindICertManager(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ICertManagerCaller{contract: contract}, nil
+}
+
+// NewICertManagerTransactor creates a new write-only instance of ICertManager, bound to a specific deployed contract.
+func NewICertManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*ICertManagerTransactor, error) {
+	contract, err := bindICertManager(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ICertManagerTransactor{contract: contract}, nil
+}
+
+// NewICertManagerFilterer creates a new log filterer instance of ICertManager, bound to a specific deployed contract.
+func NewICertManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*ICertManagerFilterer, error) {
+	contract, err := bindICertManager(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &ICertManagerFilterer{contract: contract}, nil
+}
+
+// bindICertManager binds a generic wrapper to an already deployed contract.
+func bindICertManager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := ICertManagerMetaData.GetAbi()
+	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 (_ICertManager *ICertManagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _ICertManager.Contract.ICertManagerCaller.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 (_ICertManager *ICertManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _ICertManager.Contract.ICertManagerTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_ICertManager *ICertManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _ICertManager.Contract.ICertManagerTransactor.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 (_ICertManager *ICertManagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _ICertManager.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 (_ICertManager *ICertManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _ICertManager.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_ICertManager *ICertManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _ICertManager.Contract.contract.Transact(opts, method, params...)
+}
+
+// VerifyCACert is a paid mutator transaction binding the contract method 0x0890702c.
+//
+// Solidity: function verifyCACert(bytes cert, bytes32 parentCertHash) returns(bytes32)
+func (_ICertManager *ICertManagerTransactor) VerifyCACert(opts *bind.TransactOpts, cert []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _ICertManager.contract.Transact(opts, "verifyCACert", cert, parentCertHash)
+}
+
+// VerifyCACert is a paid mutator transaction binding the contract method 0x0890702c.
+//
+// Solidity: function verifyCACert(bytes cert, bytes32 parentCertHash) returns(bytes32)
+func (_ICertManager *ICertManagerSession) VerifyCACert(cert []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _ICertManager.Contract.VerifyCACert(&_ICertManager.TransactOpts, cert, parentCertHash)
+}
+
+// VerifyCACert is a paid mutator transaction binding the contract method 0x0890702c.
+//
+// Solidity: function verifyCACert(bytes cert, bytes32 parentCertHash) returns(bytes32)
+func (_ICertManager *ICertManagerTransactorSession) VerifyCACert(cert []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _ICertManager.Contract.VerifyCACert(&_ICertManager.TransactOpts, cert, parentCertHash)
+}
+
+// VerifyClientCert is a paid mutator transaction binding the contract method 0x28c54637.
+//
+// Solidity: function verifyClientCert(bytes cert, bytes32 parentCertHash) returns((bool,uint64,int64,bytes32,bytes))
+func (_ICertManager *ICertManagerTransactor) VerifyClientCert(opts *bind.TransactOpts, cert []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _ICertManager.contract.Transact(opts, "verifyClientCert", cert, parentCertHash)
+}
+
+// VerifyClientCert is a paid mutator transaction binding the contract method 0x28c54637.
+//
+// Solidity: function verifyClientCert(bytes cert, bytes32 parentCertHash) returns((bool,uint64,int64,bytes32,bytes))
+func (_ICertManager *ICertManagerSession) VerifyClientCert(cert []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _ICertManager.Contract.VerifyClientCert(&_ICertManager.TransactOpts, cert, parentCertHash)
+}
+
+// VerifyClientCert is a paid mutator transaction binding the contract method 0x28c54637.
+//
+// Solidity: function verifyClientCert(bytes cert, bytes32 parentCertHash) returns((bool,uint64,int64,bytes32,bytes))
+func (_ICertManager *ICertManagerTransactorSession) VerifyClientCert(cert []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _ICertManager.Contract.VerifyClientCert(&_ICertManager.TransactOpts, cert, parentCertHash)
+}
+
+// IDaoAttestationResolverMetaData contains all meta data concerning the IDaoAttestationResolver contract.
+var IDaoAttestationResolverMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"attData\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"attDataHash\",\"type\":\"bytes32\"}],\"name\":\"attest\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"attestationId\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"hashAttestationid\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"}],\"name\":\"collateralHashPointer\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"collateralHashAttId\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"}],\"name\":\"collateralPointer\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"collateralAttId\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"attestationId\",\"type\":\"bytes32\"}],\"name\":\"readAttestation\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"attData\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+}
+
+// IDaoAttestationResolverABI is the input ABI used to generate the binding from.
+// Deprecated: Use IDaoAttestationResolverMetaData.ABI instead.
+var IDaoAttestationResolverABI = IDaoAttestationResolverMetaData.ABI
+
+// IDaoAttestationResolver is an auto generated Go binding around an Ethereum contract.
+type IDaoAttestationResolver struct {
+	IDaoAttestationResolverCaller     // Read-only binding to the contract
+	IDaoAttestationResolverTransactor // Write-only binding to the contract
+	IDaoAttestationResolverFilterer   // Log filterer for contract events
+}
+
+// IDaoAttestationResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
+type IDaoAttestationResolverCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IDaoAttestationResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type IDaoAttestationResolverTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IDaoAttestationResolverFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type IDaoAttestationResolverFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IDaoAttestationResolverSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type IDaoAttestationResolverSession struct {
+	Contract     *IDaoAttestationResolver // 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
+}
+
+// IDaoAttestationResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type IDaoAttestationResolverCallerSession struct {
+	Contract *IDaoAttestationResolverCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts                  // Call options to use throughout this session
+}
+
+// IDaoAttestationResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type IDaoAttestationResolverTransactorSession struct {
+	Contract     *IDaoAttestationResolverTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts                  // Transaction auth options to use throughout this session
+}
+
+// IDaoAttestationResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
+type IDaoAttestationResolverRaw struct {
+	Contract *IDaoAttestationResolver // Generic contract binding to access the raw methods on
+}
+
+// IDaoAttestationResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type IDaoAttestationResolverCallerRaw struct {
+	Contract *IDaoAttestationResolverCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// IDaoAttestationResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type IDaoAttestationResolverTransactorRaw struct {
+	Contract *IDaoAttestationResolverTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewIDaoAttestationResolver creates a new instance of IDaoAttestationResolver, bound to a specific deployed contract.
+func NewIDaoAttestationResolver(address common.Address, backend bind.ContractBackend) (*IDaoAttestationResolver, error) {
+	contract, err := bindIDaoAttestationResolver(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &IDaoAttestationResolver{IDaoAttestationResolverCaller: IDaoAttestationResolverCaller{contract: contract}, IDaoAttestationResolverTransactor: IDaoAttestationResolverTransactor{contract: contract}, IDaoAttestationResolverFilterer: IDaoAttestationResolverFilterer{contract: contract}}, nil
+}
+
+// NewIDaoAttestationResolverCaller creates a new read-only instance of IDaoAttestationResolver, bound to a specific deployed contract.
+func NewIDaoAttestationResolverCaller(address common.Address, caller bind.ContractCaller) (*IDaoAttestationResolverCaller, error) {
+	contract, err := bindIDaoAttestationResolver(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IDaoAttestationResolverCaller{contract: contract}, nil
+}
+
+// NewIDaoAttestationResolverTransactor creates a new write-only instance of IDaoAttestationResolver, bound to a specific deployed contract.
+func NewIDaoAttestationResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*IDaoAttestationResolverTransactor, error) {
+	contract, err := bindIDaoAttestationResolver(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IDaoAttestationResolverTransactor{contract: contract}, nil
+}
+
+// NewIDaoAttestationResolverFilterer creates a new log filterer instance of IDaoAttestationResolver, bound to a specific deployed contract.
+func NewIDaoAttestationResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*IDaoAttestationResolverFilterer, error) {
+	contract, err := bindIDaoAttestationResolver(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &IDaoAttestationResolverFilterer{contract: contract}, nil
+}
+
+// bindIDaoAttestationResolver binds a generic wrapper to an already deployed contract.
+func bindIDaoAttestationResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := IDaoAttestationResolverMetaData.GetAbi()
+	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 (_IDaoAttestationResolver *IDaoAttestationResolverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IDaoAttestationResolver.Contract.IDaoAttestationResolverCaller.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 (_IDaoAttestationResolver *IDaoAttestationResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IDaoAttestationResolver.Contract.IDaoAttestationResolverTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IDaoAttestationResolver *IDaoAttestationResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IDaoAttestationResolver.Contract.IDaoAttestationResolverTransactor.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 (_IDaoAttestationResolver *IDaoAttestationResolverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IDaoAttestationResolver.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 (_IDaoAttestationResolver *IDaoAttestationResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IDaoAttestationResolver.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IDaoAttestationResolver *IDaoAttestationResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IDaoAttestationResolver.Contract.contract.Transact(opts, method, params...)
+}
+
+// CollateralHashPointer is a free data retrieval call binding the contract method 0xe973fddc.
+//
+// Solidity: function collateralHashPointer(bytes32 key) view returns(bytes32 collateralHashAttId)
+func (_IDaoAttestationResolver *IDaoAttestationResolverCaller) CollateralHashPointer(opts *bind.CallOpts, key [32]byte) ([32]byte, error) {
+	var out []interface{}
+	err := _IDaoAttestationResolver.contract.Call(opts, &out, "collateralHashPointer", key)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// CollateralHashPointer is a free data retrieval call binding the contract method 0xe973fddc.
+//
+// Solidity: function collateralHashPointer(bytes32 key) view returns(bytes32 collateralHashAttId)
+func (_IDaoAttestationResolver *IDaoAttestationResolverSession) CollateralHashPointer(key [32]byte) ([32]byte, error) {
+	return _IDaoAttestationResolver.Contract.CollateralHashPointer(&_IDaoAttestationResolver.CallOpts, key)
+}
+
+// CollateralHashPointer is a free data retrieval call binding the contract method 0xe973fddc.
+//
+// Solidity: function collateralHashPointer(bytes32 key) view returns(bytes32 collateralHashAttId)
+func (_IDaoAttestationResolver *IDaoAttestationResolverCallerSession) CollateralHashPointer(key [32]byte) ([32]byte, error) {
+	return _IDaoAttestationResolver.Contract.CollateralHashPointer(&_IDaoAttestationResolver.CallOpts, key)
+}
+
+// CollateralPointer is a free data retrieval call binding the contract method 0x7fc1ca02.
+//
+// Solidity: function collateralPointer(bytes32 key) view returns(bytes32 collateralAttId)
+func (_IDaoAttestationResolver *IDaoAttestationResolverCaller) CollateralPointer(opts *bind.CallOpts, key [32]byte) ([32]byte, error) {
+	var out []interface{}
+	err := _IDaoAttestationResolver.contract.Call(opts, &out, "collateralPointer", key)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// CollateralPointer is a free data retrieval call binding the contract method 0x7fc1ca02.
+//
+// Solidity: function collateralPointer(bytes32 key) view returns(bytes32 collateralAttId)
+func (_IDaoAttestationResolver *IDaoAttestationResolverSession) CollateralPointer(key [32]byte) ([32]byte, error) {
+	return _IDaoAttestationResolver.Contract.CollateralPointer(&_IDaoAttestationResolver.CallOpts, key)
+}
+
+// CollateralPointer is a free data retrieval call binding the contract method 0x7fc1ca02.
+//
+// Solidity: function collateralPointer(bytes32 key) view returns(bytes32 collateralAttId)
+func (_IDaoAttestationResolver *IDaoAttestationResolverCallerSession) CollateralPointer(key [32]byte) ([32]byte, error) {
+	return _IDaoAttestationResolver.Contract.CollateralPointer(&_IDaoAttestationResolver.CallOpts, key)
+}
+
+// ReadAttestation is a free data retrieval call binding the contract method 0x9e5464b2.
+//
+// Solidity: function readAttestation(bytes32 attestationId) view returns(bytes attData)
+func (_IDaoAttestationResolver *IDaoAttestationResolverCaller) ReadAttestation(opts *bind.CallOpts, attestationId [32]byte) ([]byte, error) {
+	var out []interface{}
+	err := _IDaoAttestationResolver.contract.Call(opts, &out, "readAttestation", attestationId)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ReadAttestation is a free data retrieval call binding the contract method 0x9e5464b2.
+//
+// Solidity: function readAttestation(bytes32 attestationId) view returns(bytes attData)
+func (_IDaoAttestationResolver *IDaoAttestationResolverSession) ReadAttestation(attestationId [32]byte) ([]byte, error) {
+	return _IDaoAttestationResolver.Contract.ReadAttestation(&_IDaoAttestationResolver.CallOpts, attestationId)
+}
+
+// ReadAttestation is a free data retrieval call binding the contract method 0x9e5464b2.
+//
+// Solidity: function readAttestation(bytes32 attestationId) view returns(bytes attData)
+func (_IDaoAttestationResolver *IDaoAttestationResolverCallerSession) ReadAttestation(attestationId [32]byte) ([]byte, error) {
+	return _IDaoAttestationResolver.Contract.ReadAttestation(&_IDaoAttestationResolver.CallOpts, attestationId)
+}
+
+// Attest is a paid mutator transaction binding the contract method 0x5778ea32.
+//
+// Solidity: function attest(bytes32 key, bytes attData, bytes32 attDataHash) returns(bytes32 attestationId, bytes32 hashAttestationid)
+func (_IDaoAttestationResolver *IDaoAttestationResolverTransactor) Attest(opts *bind.TransactOpts, key [32]byte, attData []byte, attDataHash [32]byte) (*types.Transaction, error) {
+	return _IDaoAttestationResolver.contract.Transact(opts, "attest", key, attData, attDataHash)
+}
+
+// Attest is a paid mutator transaction binding the contract method 0x5778ea32.
+//
+// Solidity: function attest(bytes32 key, bytes attData, bytes32 attDataHash) returns(bytes32 attestationId, bytes32 hashAttestationid)
+func (_IDaoAttestationResolver *IDaoAttestationResolverSession) Attest(key [32]byte, attData []byte, attDataHash [32]byte) (*types.Transaction, error) {
+	return _IDaoAttestationResolver.Contract.Attest(&_IDaoAttestationResolver.TransactOpts, key, attData, attDataHash)
+}
+
+// Attest is a paid mutator transaction binding the contract method 0x5778ea32.
+//
+// Solidity: function attest(bytes32 key, bytes attData, bytes32 attDataHash) returns(bytes32 attestationId, bytes32 hashAttestationid)
+func (_IDaoAttestationResolver *IDaoAttestationResolverTransactorSession) Attest(key [32]byte, attData []byte, attDataHash [32]byte) (*types.Transaction, error) {
+	return _IDaoAttestationResolver.Contract.Attest(&_IDaoAttestationResolver.TransactOpts, key, attData, attDataHash)
+}
+
+// IEspressoNitroTEEVerifierMetaData contains all meta data concerning the IEspressoNitroTEEVerifier contract.
+var IEspressoNitroTEEVerifierMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"certHash\",\"type\":\"bytes32\"}],\"name\":\"certVerified\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"signers\",\"type\":\"address[]\"}],\"name\":\"deleteRegisteredSigners\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"attestation\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"registerSigner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"}],\"name\":\"registeredEnclaveHash\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"registeredSigners\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"},{\"internalType\":\"bool\",\"name\":\"valid\",\"type\":\"bool\"}],\"name\":\"setEnclaveHash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"certificate\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"parentCertHash\",\"type\":\"bytes32\"}],\"name\":\"verifyCACert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"certificate\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"parentCertHash\",\"type\":\"bytes32\"}],\"name\":\"verifyClientCert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"valid\",\"type\":\"bool\"}],\"name\":\"AWSEnclaveHashSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"}],\"name\":\"AWSSignerRegistered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"DeletedAWSRegisteredSigner\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"InvalidAWSEnclaveHash\",\"type\":\"error\"}]",
+}
+
+// IEspressoNitroTEEVerifierABI is the input ABI used to generate the binding from.
+// Deprecated: Use IEspressoNitroTEEVerifierMetaData.ABI instead.
+var IEspressoNitroTEEVerifierABI = IEspressoNitroTEEVerifierMetaData.ABI
+
+// IEspressoNitroTEEVerifier is an auto generated Go binding around an Ethereum contract.
+type IEspressoNitroTEEVerifier struct {
+	IEspressoNitroTEEVerifierCaller     // Read-only binding to the contract
+	IEspressoNitroTEEVerifierTransactor // Write-only binding to the contract
+	IEspressoNitroTEEVerifierFilterer   // Log filterer for contract events
+}
+
+// IEspressoNitroTEEVerifierCaller is an auto generated read-only Go binding around an Ethereum contract.
+type IEspressoNitroTEEVerifierCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IEspressoNitroTEEVerifierTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type IEspressoNitroTEEVerifierTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IEspressoNitroTEEVerifierFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type IEspressoNitroTEEVerifierFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IEspressoNitroTEEVerifierSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type IEspressoNitroTEEVerifierSession struct {
+	Contract     *IEspressoNitroTEEVerifier // 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
+}
+
+// IEspressoNitroTEEVerifierCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type IEspressoNitroTEEVerifierCallerSession struct {
+	Contract *IEspressoNitroTEEVerifierCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts                    // Call options to use throughout this session
+}
+
+// IEspressoNitroTEEVerifierTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type IEspressoNitroTEEVerifierTransactorSession struct {
+	Contract     *IEspressoNitroTEEVerifierTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts                    // Transaction auth options to use throughout this session
+}
+
+// IEspressoNitroTEEVerifierRaw is an auto generated low-level Go binding around an Ethereum contract.
+type IEspressoNitroTEEVerifierRaw struct {
+	Contract *IEspressoNitroTEEVerifier // Generic contract binding to access the raw methods on
+}
+
+// IEspressoNitroTEEVerifierCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type IEspressoNitroTEEVerifierCallerRaw struct {
+	Contract *IEspressoNitroTEEVerifierCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// IEspressoNitroTEEVerifierTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type IEspressoNitroTEEVerifierTransactorRaw struct {
+	Contract *IEspressoNitroTEEVerifierTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewIEspressoNitroTEEVerifier creates a new instance of IEspressoNitroTEEVerifier, bound to a specific deployed contract.
+func NewIEspressoNitroTEEVerifier(address common.Address, backend bind.ContractBackend) (*IEspressoNitroTEEVerifier, error) {
+	contract, err := bindIEspressoNitroTEEVerifier(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoNitroTEEVerifier{IEspressoNitroTEEVerifierCaller: IEspressoNitroTEEVerifierCaller{contract: contract}, IEspressoNitroTEEVerifierTransactor: IEspressoNitroTEEVerifierTransactor{contract: contract}, IEspressoNitroTEEVerifierFilterer: IEspressoNitroTEEVerifierFilterer{contract: contract}}, nil
+}
+
+// NewIEspressoNitroTEEVerifierCaller creates a new read-only instance of IEspressoNitroTEEVerifier, bound to a specific deployed contract.
+func NewIEspressoNitroTEEVerifierCaller(address common.Address, caller bind.ContractCaller) (*IEspressoNitroTEEVerifierCaller, error) {
+	contract, err := bindIEspressoNitroTEEVerifier(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoNitroTEEVerifierCaller{contract: contract}, nil
+}
+
+// NewIEspressoNitroTEEVerifierTransactor creates a new write-only instance of IEspressoNitroTEEVerifier, bound to a specific deployed contract.
+func NewIEspressoNitroTEEVerifierTransactor(address common.Address, transactor bind.ContractTransactor) (*IEspressoNitroTEEVerifierTransactor, error) {
+	contract, err := bindIEspressoNitroTEEVerifier(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoNitroTEEVerifierTransactor{contract: contract}, nil
+}
+
+// NewIEspressoNitroTEEVerifierFilterer creates a new log filterer instance of IEspressoNitroTEEVerifier, bound to a specific deployed contract.
+func NewIEspressoNitroTEEVerifierFilterer(address common.Address, filterer bind.ContractFilterer) (*IEspressoNitroTEEVerifierFilterer, error) {
+	contract, err := bindIEspressoNitroTEEVerifier(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoNitroTEEVerifierFilterer{contract: contract}, nil
+}
+
+// bindIEspressoNitroTEEVerifier binds a generic wrapper to an already deployed contract.
+func bindIEspressoNitroTEEVerifier(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := IEspressoNitroTEEVerifierMetaData.GetAbi()
+	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 (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IEspressoNitroTEEVerifier.Contract.IEspressoNitroTEEVerifierCaller.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 (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.IEspressoNitroTEEVerifierTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.IEspressoNitroTEEVerifierTransactor.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 (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IEspressoNitroTEEVerifier.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 (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.contract.Transact(opts, method, params...)
+}
+
+// CertVerified is a free data retrieval call binding the contract method 0x676d1daa.
+//
+// Solidity: function certVerified(bytes32 certHash) view returns(bool)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierCaller) CertVerified(opts *bind.CallOpts, certHash [32]byte) (bool, error) {
+	var out []interface{}
+	err := _IEspressoNitroTEEVerifier.contract.Call(opts, &out, "certVerified", certHash)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// CertVerified is a free data retrieval call binding the contract method 0x676d1daa.
+//
+// Solidity: function certVerified(bytes32 certHash) view returns(bool)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierSession) CertVerified(certHash [32]byte) (bool, error) {
+	return _IEspressoNitroTEEVerifier.Contract.CertVerified(&_IEspressoNitroTEEVerifier.CallOpts, certHash)
+}
+
+// CertVerified is a free data retrieval call binding the contract method 0x676d1daa.
+//
+// Solidity: function certVerified(bytes32 certHash) view returns(bool)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierCallerSession) CertVerified(certHash [32]byte) (bool, error) {
+	return _IEspressoNitroTEEVerifier.Contract.CertVerified(&_IEspressoNitroTEEVerifier.CallOpts, certHash)
+}
+
+// RegisteredEnclaveHash is a free data retrieval call binding the contract method 0x966989ee.
+//
+// Solidity: function registeredEnclaveHash(bytes32 enclaveHash) view returns(bool)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierCaller) RegisteredEnclaveHash(opts *bind.CallOpts, enclaveHash [32]byte) (bool, error) {
+	var out []interface{}
+	err := _IEspressoNitroTEEVerifier.contract.Call(opts, &out, "registeredEnclaveHash", enclaveHash)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredEnclaveHash is a free data retrieval call binding the contract method 0x966989ee.
+//
+// Solidity: function registeredEnclaveHash(bytes32 enclaveHash) view returns(bool)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierSession) RegisteredEnclaveHash(enclaveHash [32]byte) (bool, error) {
+	return _IEspressoNitroTEEVerifier.Contract.RegisteredEnclaveHash(&_IEspressoNitroTEEVerifier.CallOpts, enclaveHash)
+}
+
+// RegisteredEnclaveHash is a free data retrieval call binding the contract method 0x966989ee.
+//
+// Solidity: function registeredEnclaveHash(bytes32 enclaveHash) view returns(bool)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierCallerSession) RegisteredEnclaveHash(enclaveHash [32]byte) (bool, error) {
+	return _IEspressoNitroTEEVerifier.Contract.RegisteredEnclaveHash(&_IEspressoNitroTEEVerifier.CallOpts, enclaveHash)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0x0123d0c1.
+//
+// Solidity: function registeredSigners(address signer) view returns(bool)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierCaller) RegisteredSigners(opts *bind.CallOpts, signer common.Address) (bool, error) {
+	var out []interface{}
+	err := _IEspressoNitroTEEVerifier.contract.Call(opts, &out, "registeredSigners", signer)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0x0123d0c1.
+//
+// Solidity: function registeredSigners(address signer) view returns(bool)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierSession) RegisteredSigners(signer common.Address) (bool, error) {
+	return _IEspressoNitroTEEVerifier.Contract.RegisteredSigners(&_IEspressoNitroTEEVerifier.CallOpts, signer)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0x0123d0c1.
+//
+// Solidity: function registeredSigners(address signer) view returns(bool)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierCallerSession) RegisteredSigners(signer common.Address) (bool, error) {
+	return _IEspressoNitroTEEVerifier.Contract.RegisteredSigners(&_IEspressoNitroTEEVerifier.CallOpts, signer)
+}
+
+// DeleteRegisteredSigners is a paid mutator transaction binding the contract method 0xe7370be0.
+//
+// Solidity: function deleteRegisteredSigners(address[] signers) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierTransactor) DeleteRegisteredSigners(opts *bind.TransactOpts, signers []common.Address) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.contract.Transact(opts, "deleteRegisteredSigners", signers)
+}
+
+// DeleteRegisteredSigners is a paid mutator transaction binding the contract method 0xe7370be0.
+//
+// Solidity: function deleteRegisteredSigners(address[] signers) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierSession) DeleteRegisteredSigners(signers []common.Address) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.DeleteRegisteredSigners(&_IEspressoNitroTEEVerifier.TransactOpts, signers)
+}
+
+// DeleteRegisteredSigners is a paid mutator transaction binding the contract method 0xe7370be0.
+//
+// Solidity: function deleteRegisteredSigners(address[] signers) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierTransactorSession) DeleteRegisteredSigners(signers []common.Address) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.DeleteRegisteredSigners(&_IEspressoNitroTEEVerifier.TransactOpts, signers)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0xba58e82a.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierTransactor) RegisterSigner(opts *bind.TransactOpts, attestation []byte, data []byte) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.contract.Transact(opts, "registerSigner", attestation, data)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0xba58e82a.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierSession) RegisterSigner(attestation []byte, data []byte) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.RegisterSigner(&_IEspressoNitroTEEVerifier.TransactOpts, attestation, data)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0xba58e82a.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierTransactorSession) RegisterSigner(attestation []byte, data []byte) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.RegisterSigner(&_IEspressoNitroTEEVerifier.TransactOpts, attestation, data)
+}
+
+// SetEnclaveHash is a paid mutator transaction binding the contract method 0x93b5552e.
+//
+// Solidity: function setEnclaveHash(bytes32 enclaveHash, bool valid) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierTransactor) SetEnclaveHash(opts *bind.TransactOpts, enclaveHash [32]byte, valid bool) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.contract.Transact(opts, "setEnclaveHash", enclaveHash, valid)
+}
+
+// SetEnclaveHash is a paid mutator transaction binding the contract method 0x93b5552e.
+//
+// Solidity: function setEnclaveHash(bytes32 enclaveHash, bool valid) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierSession) SetEnclaveHash(enclaveHash [32]byte, valid bool) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.SetEnclaveHash(&_IEspressoNitroTEEVerifier.TransactOpts, enclaveHash, valid)
+}
+
+// SetEnclaveHash is a paid mutator transaction binding the contract method 0x93b5552e.
+//
+// Solidity: function setEnclaveHash(bytes32 enclaveHash, bool valid) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierTransactorSession) SetEnclaveHash(enclaveHash [32]byte, valid bool) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.SetEnclaveHash(&_IEspressoNitroTEEVerifier.TransactOpts, enclaveHash, valid)
+}
+
+// VerifyCACert is a paid mutator transaction binding the contract method 0x0890702c.
+//
+// Solidity: function verifyCACert(bytes certificate, bytes32 parentCertHash) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierTransactor) VerifyCACert(opts *bind.TransactOpts, certificate []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.contract.Transact(opts, "verifyCACert", certificate, parentCertHash)
+}
+
+// VerifyCACert is a paid mutator transaction binding the contract method 0x0890702c.
+//
+// Solidity: function verifyCACert(bytes certificate, bytes32 parentCertHash) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierSession) VerifyCACert(certificate []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.VerifyCACert(&_IEspressoNitroTEEVerifier.TransactOpts, certificate, parentCertHash)
+}
+
+// VerifyCACert is a paid mutator transaction binding the contract method 0x0890702c.
+//
+// Solidity: function verifyCACert(bytes certificate, bytes32 parentCertHash) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierTransactorSession) VerifyCACert(certificate []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.VerifyCACert(&_IEspressoNitroTEEVerifier.TransactOpts, certificate, parentCertHash)
+}
+
+// VerifyClientCert is a paid mutator transaction binding the contract method 0x28c54637.
+//
+// Solidity: function verifyClientCert(bytes certificate, bytes32 parentCertHash) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierTransactor) VerifyClientCert(opts *bind.TransactOpts, certificate []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.contract.Transact(opts, "verifyClientCert", certificate, parentCertHash)
+}
+
+// VerifyClientCert is a paid mutator transaction binding the contract method 0x28c54637.
+//
+// Solidity: function verifyClientCert(bytes certificate, bytes32 parentCertHash) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierSession) VerifyClientCert(certificate []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.VerifyClientCert(&_IEspressoNitroTEEVerifier.TransactOpts, certificate, parentCertHash)
+}
+
+// VerifyClientCert is a paid mutator transaction binding the contract method 0x28c54637.
+//
+// Solidity: function verifyClientCert(bytes certificate, bytes32 parentCertHash) returns()
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierTransactorSession) VerifyClientCert(certificate []byte, parentCertHash [32]byte) (*types.Transaction, error) {
+	return _IEspressoNitroTEEVerifier.Contract.VerifyClientCert(&_IEspressoNitroTEEVerifier.TransactOpts, certificate, parentCertHash)
+}
+
+// IEspressoNitroTEEVerifierAWSEnclaveHashSetIterator is returned from FilterAWSEnclaveHashSet and is used to iterate over the raw logs and unpacked data for AWSEnclaveHashSet events raised by the IEspressoNitroTEEVerifier contract.
+type IEspressoNitroTEEVerifierAWSEnclaveHashSetIterator struct {
+	Event *IEspressoNitroTEEVerifierAWSEnclaveHashSet // 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 *IEspressoNitroTEEVerifierAWSEnclaveHashSetIterator) 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(IEspressoNitroTEEVerifierAWSEnclaveHashSet)
+			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(IEspressoNitroTEEVerifierAWSEnclaveHashSet)
+		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 *IEspressoNitroTEEVerifierAWSEnclaveHashSetIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *IEspressoNitroTEEVerifierAWSEnclaveHashSetIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// IEspressoNitroTEEVerifierAWSEnclaveHashSet represents a AWSEnclaveHashSet event raised by the IEspressoNitroTEEVerifier contract.
+type IEspressoNitroTEEVerifierAWSEnclaveHashSet struct {
+	EnclaveHash [32]byte
+	Valid       bool
+	Raw         types.Log // Blockchain specific contextual infos
+}
+
+// FilterAWSEnclaveHashSet is a free log retrieval operation binding the contract event 0xb1f2a28cb3375145c700e1f69909129b208757ae95af38315661980b83a4da6a.
+//
+// Solidity: event AWSEnclaveHashSet(bytes32 enclaveHash, bool valid)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierFilterer) FilterAWSEnclaveHashSet(opts *bind.FilterOpts) (*IEspressoNitroTEEVerifierAWSEnclaveHashSetIterator, error) {
+
+	logs, sub, err := _IEspressoNitroTEEVerifier.contract.FilterLogs(opts, "AWSEnclaveHashSet")
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoNitroTEEVerifierAWSEnclaveHashSetIterator{contract: _IEspressoNitroTEEVerifier.contract, event: "AWSEnclaveHashSet", logs: logs, sub: sub}, nil
+}
+
+// WatchAWSEnclaveHashSet is a free log subscription operation binding the contract event 0xb1f2a28cb3375145c700e1f69909129b208757ae95af38315661980b83a4da6a.
+//
+// Solidity: event AWSEnclaveHashSet(bytes32 enclaveHash, bool valid)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierFilterer) WatchAWSEnclaveHashSet(opts *bind.WatchOpts, sink chan<- *IEspressoNitroTEEVerifierAWSEnclaveHashSet) (event.Subscription, error) {
+
+	logs, sub, err := _IEspressoNitroTEEVerifier.contract.WatchLogs(opts, "AWSEnclaveHashSet")
+	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(IEspressoNitroTEEVerifierAWSEnclaveHashSet)
+				if err := _IEspressoNitroTEEVerifier.contract.UnpackLog(event, "AWSEnclaveHashSet", 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
+}
+
+// ParseAWSEnclaveHashSet is a log parse operation binding the contract event 0xb1f2a28cb3375145c700e1f69909129b208757ae95af38315661980b83a4da6a.
+//
+// Solidity: event AWSEnclaveHashSet(bytes32 enclaveHash, bool valid)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierFilterer) ParseAWSEnclaveHashSet(log types.Log) (*IEspressoNitroTEEVerifierAWSEnclaveHashSet, error) {
+	event := new(IEspressoNitroTEEVerifierAWSEnclaveHashSet)
+	if err := _IEspressoNitroTEEVerifier.contract.UnpackLog(event, "AWSEnclaveHashSet", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// IEspressoNitroTEEVerifierAWSSignerRegisteredIterator is returned from FilterAWSSignerRegistered and is used to iterate over the raw logs and unpacked data for AWSSignerRegistered events raised by the IEspressoNitroTEEVerifier contract.
+type IEspressoNitroTEEVerifierAWSSignerRegisteredIterator struct {
+	Event *IEspressoNitroTEEVerifierAWSSignerRegistered // 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 *IEspressoNitroTEEVerifierAWSSignerRegisteredIterator) 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(IEspressoNitroTEEVerifierAWSSignerRegistered)
+			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(IEspressoNitroTEEVerifierAWSSignerRegistered)
+		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 *IEspressoNitroTEEVerifierAWSSignerRegisteredIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *IEspressoNitroTEEVerifierAWSSignerRegisteredIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// IEspressoNitroTEEVerifierAWSSignerRegistered represents a AWSSignerRegistered event raised by the IEspressoNitroTEEVerifier contract.
+type IEspressoNitroTEEVerifierAWSSignerRegistered struct {
+	Signer      common.Address
+	EnclaveHash [32]byte
+	Raw         types.Log // Blockchain specific contextual infos
+}
+
+// FilterAWSSignerRegistered is a free log retrieval operation binding the contract event 0x9dff6e00687e8d1229e18cae12d584610f9457243f95f608acd266087a4ed357.
+//
+// Solidity: event AWSSignerRegistered(address signer, bytes32 enclaveHash)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierFilterer) FilterAWSSignerRegistered(opts *bind.FilterOpts) (*IEspressoNitroTEEVerifierAWSSignerRegisteredIterator, error) {
+
+	logs, sub, err := _IEspressoNitroTEEVerifier.contract.FilterLogs(opts, "AWSSignerRegistered")
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoNitroTEEVerifierAWSSignerRegisteredIterator{contract: _IEspressoNitroTEEVerifier.contract, event: "AWSSignerRegistered", logs: logs, sub: sub}, nil
+}
+
+// WatchAWSSignerRegistered is a free log subscription operation binding the contract event 0x9dff6e00687e8d1229e18cae12d584610f9457243f95f608acd266087a4ed357.
+//
+// Solidity: event AWSSignerRegistered(address signer, bytes32 enclaveHash)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierFilterer) WatchAWSSignerRegistered(opts *bind.WatchOpts, sink chan<- *IEspressoNitroTEEVerifierAWSSignerRegistered) (event.Subscription, error) {
+
+	logs, sub, err := _IEspressoNitroTEEVerifier.contract.WatchLogs(opts, "AWSSignerRegistered")
+	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(IEspressoNitroTEEVerifierAWSSignerRegistered)
+				if err := _IEspressoNitroTEEVerifier.contract.UnpackLog(event, "AWSSignerRegistered", 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
+}
+
+// ParseAWSSignerRegistered is a log parse operation binding the contract event 0x9dff6e00687e8d1229e18cae12d584610f9457243f95f608acd266087a4ed357.
+//
+// Solidity: event AWSSignerRegistered(address signer, bytes32 enclaveHash)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierFilterer) ParseAWSSignerRegistered(log types.Log) (*IEspressoNitroTEEVerifierAWSSignerRegistered, error) {
+	event := new(IEspressoNitroTEEVerifierAWSSignerRegistered)
+	if err := _IEspressoNitroTEEVerifier.contract.UnpackLog(event, "AWSSignerRegistered", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// IEspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator is returned from FilterDeletedAWSRegisteredSigner and is used to iterate over the raw logs and unpacked data for DeletedAWSRegisteredSigner events raised by the IEspressoNitroTEEVerifier contract.
+type IEspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator struct {
+	Event *IEspressoNitroTEEVerifierDeletedAWSRegisteredSigner // 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 *IEspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator) 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(IEspressoNitroTEEVerifierDeletedAWSRegisteredSigner)
+			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(IEspressoNitroTEEVerifierDeletedAWSRegisteredSigner)
+		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 *IEspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *IEspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// IEspressoNitroTEEVerifierDeletedAWSRegisteredSigner represents a DeletedAWSRegisteredSigner event raised by the IEspressoNitroTEEVerifier contract.
+type IEspressoNitroTEEVerifierDeletedAWSRegisteredSigner struct {
+	Signer common.Address
+	Raw    types.Log // Blockchain specific contextual infos
+}
+
+// FilterDeletedAWSRegisteredSigner is a free log retrieval operation binding the contract event 0x6e6ee65b6e46fb8aa8f338575749d68bd7540f2244a4aa22ed24ed56cd77392c.
+//
+// Solidity: event DeletedAWSRegisteredSigner(address signer)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierFilterer) FilterDeletedAWSRegisteredSigner(opts *bind.FilterOpts) (*IEspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator, error) {
+
+	logs, sub, err := _IEspressoNitroTEEVerifier.contract.FilterLogs(opts, "DeletedAWSRegisteredSigner")
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoNitroTEEVerifierDeletedAWSRegisteredSignerIterator{contract: _IEspressoNitroTEEVerifier.contract, event: "DeletedAWSRegisteredSigner", logs: logs, sub: sub}, nil
+}
+
+// WatchDeletedAWSRegisteredSigner is a free log subscription operation binding the contract event 0x6e6ee65b6e46fb8aa8f338575749d68bd7540f2244a4aa22ed24ed56cd77392c.
+//
+// Solidity: event DeletedAWSRegisteredSigner(address signer)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierFilterer) WatchDeletedAWSRegisteredSigner(opts *bind.WatchOpts, sink chan<- *IEspressoNitroTEEVerifierDeletedAWSRegisteredSigner) (event.Subscription, error) {
+
+	logs, sub, err := _IEspressoNitroTEEVerifier.contract.WatchLogs(opts, "DeletedAWSRegisteredSigner")
+	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(IEspressoNitroTEEVerifierDeletedAWSRegisteredSigner)
+				if err := _IEspressoNitroTEEVerifier.contract.UnpackLog(event, "DeletedAWSRegisteredSigner", 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
+}
+
+// ParseDeletedAWSRegisteredSigner is a log parse operation binding the contract event 0x6e6ee65b6e46fb8aa8f338575749d68bd7540f2244a4aa22ed24ed56cd77392c.
+//
+// Solidity: event DeletedAWSRegisteredSigner(address signer)
+func (_IEspressoNitroTEEVerifier *IEspressoNitroTEEVerifierFilterer) ParseDeletedAWSRegisteredSigner(log types.Log) (*IEspressoNitroTEEVerifierDeletedAWSRegisteredSigner, error) {
+	event := new(IEspressoNitroTEEVerifierDeletedAWSRegisteredSigner)
+	if err := _IEspressoNitroTEEVerifier.contract.UnpackLog(event, "DeletedAWSRegisteredSigner", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// IEspressoRollupSequencerManagerMetaData contains all meta data concerning the IEspressoRollupSequencerManager contract.
+var IEspressoRollupSequencerManagerMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"getCurrentSequencer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"}],\"name\":\"insertSequencer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"}],\"name\":\"removeSequencer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"SequencerAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"SequencerRemoved\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"InvalidSequencer\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequencerAlreadyExists\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequencerDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequencerListIsEmpty\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Unauthorized\",\"type\":\"error\"}]",
+}
+
+// IEspressoRollupSequencerManagerABI is the input ABI used to generate the binding from.
+// Deprecated: Use IEspressoRollupSequencerManagerMetaData.ABI instead.
+var IEspressoRollupSequencerManagerABI = IEspressoRollupSequencerManagerMetaData.ABI
+
+// IEspressoRollupSequencerManager is an auto generated Go binding around an Ethereum contract.
+type IEspressoRollupSequencerManager struct {
+	IEspressoRollupSequencerManagerCaller     // Read-only binding to the contract
+	IEspressoRollupSequencerManagerTransactor // Write-only binding to the contract
+	IEspressoRollupSequencerManagerFilterer   // Log filterer for contract events
+}
+
+// IEspressoRollupSequencerManagerCaller is an auto generated read-only Go binding around an Ethereum contract.
+type IEspressoRollupSequencerManagerCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IEspressoRollupSequencerManagerTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type IEspressoRollupSequencerManagerTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IEspressoRollupSequencerManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type IEspressoRollupSequencerManagerFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IEspressoRollupSequencerManagerSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type IEspressoRollupSequencerManagerSession struct {
+	Contract     *IEspressoRollupSequencerManager // 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
+}
+
+// IEspressoRollupSequencerManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type IEspressoRollupSequencerManagerCallerSession struct {
+	Contract *IEspressoRollupSequencerManagerCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts                          // Call options to use throughout this session
+}
+
+// IEspressoRollupSequencerManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type IEspressoRollupSequencerManagerTransactorSession struct {
+	Contract     *IEspressoRollupSequencerManagerTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts                          // Transaction auth options to use throughout this session
+}
+
+// IEspressoRollupSequencerManagerRaw is an auto generated low-level Go binding around an Ethereum contract.
+type IEspressoRollupSequencerManagerRaw struct {
+	Contract *IEspressoRollupSequencerManager // Generic contract binding to access the raw methods on
+}
+
+// IEspressoRollupSequencerManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type IEspressoRollupSequencerManagerCallerRaw struct {
+	Contract *IEspressoRollupSequencerManagerCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// IEspressoRollupSequencerManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type IEspressoRollupSequencerManagerTransactorRaw struct {
+	Contract *IEspressoRollupSequencerManagerTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewIEspressoRollupSequencerManager creates a new instance of IEspressoRollupSequencerManager, bound to a specific deployed contract.
+func NewIEspressoRollupSequencerManager(address common.Address, backend bind.ContractBackend) (*IEspressoRollupSequencerManager, error) {
+	contract, err := bindIEspressoRollupSequencerManager(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoRollupSequencerManager{IEspressoRollupSequencerManagerCaller: IEspressoRollupSequencerManagerCaller{contract: contract}, IEspressoRollupSequencerManagerTransactor: IEspressoRollupSequencerManagerTransactor{contract: contract}, IEspressoRollupSequencerManagerFilterer: IEspressoRollupSequencerManagerFilterer{contract: contract}}, nil
+}
+
+// NewIEspressoRollupSequencerManagerCaller creates a new read-only instance of IEspressoRollupSequencerManager, bound to a specific deployed contract.
+func NewIEspressoRollupSequencerManagerCaller(address common.Address, caller bind.ContractCaller) (*IEspressoRollupSequencerManagerCaller, error) {
+	contract, err := bindIEspressoRollupSequencerManager(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoRollupSequencerManagerCaller{contract: contract}, nil
+}
+
+// NewIEspressoRollupSequencerManagerTransactor creates a new write-only instance of IEspressoRollupSequencerManager, bound to a specific deployed contract.
+func NewIEspressoRollupSequencerManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*IEspressoRollupSequencerManagerTransactor, error) {
+	contract, err := bindIEspressoRollupSequencerManager(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoRollupSequencerManagerTransactor{contract: contract}, nil
+}
+
+// NewIEspressoRollupSequencerManagerFilterer creates a new log filterer instance of IEspressoRollupSequencerManager, bound to a specific deployed contract.
+func NewIEspressoRollupSequencerManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*IEspressoRollupSequencerManagerFilterer, error) {
+	contract, err := bindIEspressoRollupSequencerManager(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoRollupSequencerManagerFilterer{contract: contract}, nil
+}
+
+// bindIEspressoRollupSequencerManager binds a generic wrapper to an already deployed contract.
+func bindIEspressoRollupSequencerManager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := IEspressoRollupSequencerManagerMetaData.GetAbi()
+	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 (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IEspressoRollupSequencerManager.Contract.IEspressoRollupSequencerManagerCaller.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 (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IEspressoRollupSequencerManager.Contract.IEspressoRollupSequencerManagerTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IEspressoRollupSequencerManager.Contract.IEspressoRollupSequencerManagerTransactor.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 (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IEspressoRollupSequencerManager.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 (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IEspressoRollupSequencerManager.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IEspressoRollupSequencerManager.Contract.contract.Transact(opts, method, params...)
+}
+
+// GetCurrentSequencer is a free data retrieval call binding the contract method 0x25cb5685.
+//
+// Solidity: function getCurrentSequencer(uint256 nonce) view returns(address)
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerCaller) GetCurrentSequencer(opts *bind.CallOpts, nonce *big.Int) (common.Address, error) {
+	var out []interface{}
+	err := _IEspressoRollupSequencerManager.contract.Call(opts, &out, "getCurrentSequencer", nonce)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// GetCurrentSequencer is a free data retrieval call binding the contract method 0x25cb5685.
+//
+// Solidity: function getCurrentSequencer(uint256 nonce) view returns(address)
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerSession) GetCurrentSequencer(nonce *big.Int) (common.Address, error) {
+	return _IEspressoRollupSequencerManager.Contract.GetCurrentSequencer(&_IEspressoRollupSequencerManager.CallOpts, nonce)
+}
+
+// GetCurrentSequencer is a free data retrieval call binding the contract method 0x25cb5685.
+//
+// Solidity: function getCurrentSequencer(uint256 nonce) view returns(address)
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerCallerSession) GetCurrentSequencer(nonce *big.Int) (common.Address, error) {
+	return _IEspressoRollupSequencerManager.Contract.GetCurrentSequencer(&_IEspressoRollupSequencerManager.CallOpts, nonce)
+}
+
+// InsertSequencer is a paid mutator transaction binding the contract method 0xa5b41b73.
+//
+// Solidity: function insertSequencer(address sequencer) returns()
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerTransactor) InsertSequencer(opts *bind.TransactOpts, sequencer common.Address) (*types.Transaction, error) {
+	return _IEspressoRollupSequencerManager.contract.Transact(opts, "insertSequencer", sequencer)
+}
+
+// InsertSequencer is a paid mutator transaction binding the contract method 0xa5b41b73.
+//
+// Solidity: function insertSequencer(address sequencer) returns()
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerSession) InsertSequencer(sequencer common.Address) (*types.Transaction, error) {
+	return _IEspressoRollupSequencerManager.Contract.InsertSequencer(&_IEspressoRollupSequencerManager.TransactOpts, sequencer)
+}
+
+// InsertSequencer is a paid mutator transaction binding the contract method 0xa5b41b73.
+//
+// Solidity: function insertSequencer(address sequencer) returns()
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerTransactorSession) InsertSequencer(sequencer common.Address) (*types.Transaction, error) {
+	return _IEspressoRollupSequencerManager.Contract.InsertSequencer(&_IEspressoRollupSequencerManager.TransactOpts, sequencer)
+}
+
+// RemoveSequencer is a paid mutator transaction binding the contract method 0x6989ca7c.
+//
+// Solidity: function removeSequencer(address sequencer) returns()
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerTransactor) RemoveSequencer(opts *bind.TransactOpts, sequencer common.Address) (*types.Transaction, error) {
+	return _IEspressoRollupSequencerManager.contract.Transact(opts, "removeSequencer", sequencer)
+}
+
+// RemoveSequencer is a paid mutator transaction binding the contract method 0x6989ca7c.
+//
+// Solidity: function removeSequencer(address sequencer) returns()
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerSession) RemoveSequencer(sequencer common.Address) (*types.Transaction, error) {
+	return _IEspressoRollupSequencerManager.Contract.RemoveSequencer(&_IEspressoRollupSequencerManager.TransactOpts, sequencer)
+}
+
+// RemoveSequencer is a paid mutator transaction binding the contract method 0x6989ca7c.
+//
+// Solidity: function removeSequencer(address sequencer) returns()
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerTransactorSession) RemoveSequencer(sequencer common.Address) (*types.Transaction, error) {
+	return _IEspressoRollupSequencerManager.Contract.RemoveSequencer(&_IEspressoRollupSequencerManager.TransactOpts, sequencer)
+}
+
+// IEspressoRollupSequencerManagerSequencerAddedIterator is returned from FilterSequencerAdded and is used to iterate over the raw logs and unpacked data for SequencerAdded events raised by the IEspressoRollupSequencerManager contract.
+type IEspressoRollupSequencerManagerSequencerAddedIterator struct {
+	Event *IEspressoRollupSequencerManagerSequencerAdded // 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 *IEspressoRollupSequencerManagerSequencerAddedIterator) 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(IEspressoRollupSequencerManagerSequencerAdded)
+			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(IEspressoRollupSequencerManagerSequencerAdded)
+		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 *IEspressoRollupSequencerManagerSequencerAddedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *IEspressoRollupSequencerManagerSequencerAddedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// IEspressoRollupSequencerManagerSequencerAdded represents a SequencerAdded event raised by the IEspressoRollupSequencerManager contract.
+type IEspressoRollupSequencerManagerSequencerAdded struct {
+	Sequencer common.Address
+	Nonce     *big.Int
+	Raw       types.Log // Blockchain specific contextual infos
+}
+
+// FilterSequencerAdded is a free log retrieval operation binding the contract event 0x4fd176ea5a84f3047cc893049bb44ef7418b01c9e07affb753a6847a9cfd6a66.
+//
+// Solidity: event SequencerAdded(address indexed sequencer, uint256 indexed nonce)
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerFilterer) FilterSequencerAdded(opts *bind.FilterOpts, sequencer []common.Address, nonce []*big.Int) (*IEspressoRollupSequencerManagerSequencerAddedIterator, error) {
+
+	var sequencerRule []interface{}
+	for _, sequencerItem := range sequencer {
+		sequencerRule = append(sequencerRule, sequencerItem)
+	}
+	var nonceRule []interface{}
+	for _, nonceItem := range nonce {
+		nonceRule = append(nonceRule, nonceItem)
+	}
+
+	logs, sub, err := _IEspressoRollupSequencerManager.contract.FilterLogs(opts, "SequencerAdded", sequencerRule, nonceRule)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoRollupSequencerManagerSequencerAddedIterator{contract: _IEspressoRollupSequencerManager.contract, event: "SequencerAdded", logs: logs, sub: sub}, nil
+}
+
+// WatchSequencerAdded is a free log subscription operation binding the contract event 0x4fd176ea5a84f3047cc893049bb44ef7418b01c9e07affb753a6847a9cfd6a66.
+//
+// Solidity: event SequencerAdded(address indexed sequencer, uint256 indexed nonce)
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerFilterer) WatchSequencerAdded(opts *bind.WatchOpts, sink chan<- *IEspressoRollupSequencerManagerSequencerAdded, sequencer []common.Address, nonce []*big.Int) (event.Subscription, error) {
+
+	var sequencerRule []interface{}
+	for _, sequencerItem := range sequencer {
+		sequencerRule = append(sequencerRule, sequencerItem)
+	}
+	var nonceRule []interface{}
+	for _, nonceItem := range nonce {
+		nonceRule = append(nonceRule, nonceItem)
+	}
+
+	logs, sub, err := _IEspressoRollupSequencerManager.contract.WatchLogs(opts, "SequencerAdded", sequencerRule, nonceRule)
+	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(IEspressoRollupSequencerManagerSequencerAdded)
+				if err := _IEspressoRollupSequencerManager.contract.UnpackLog(event, "SequencerAdded", 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
+}
+
+// ParseSequencerAdded is a log parse operation binding the contract event 0x4fd176ea5a84f3047cc893049bb44ef7418b01c9e07affb753a6847a9cfd6a66.
+//
+// Solidity: event SequencerAdded(address indexed sequencer, uint256 indexed nonce)
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerFilterer) ParseSequencerAdded(log types.Log) (*IEspressoRollupSequencerManagerSequencerAdded, error) {
+	event := new(IEspressoRollupSequencerManagerSequencerAdded)
+	if err := _IEspressoRollupSequencerManager.contract.UnpackLog(event, "SequencerAdded", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// IEspressoRollupSequencerManagerSequencerRemovedIterator is returned from FilterSequencerRemoved and is used to iterate over the raw logs and unpacked data for SequencerRemoved events raised by the IEspressoRollupSequencerManager contract.
+type IEspressoRollupSequencerManagerSequencerRemovedIterator struct {
+	Event *IEspressoRollupSequencerManagerSequencerRemoved // 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 *IEspressoRollupSequencerManagerSequencerRemovedIterator) 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(IEspressoRollupSequencerManagerSequencerRemoved)
+			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(IEspressoRollupSequencerManagerSequencerRemoved)
+		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 *IEspressoRollupSequencerManagerSequencerRemovedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *IEspressoRollupSequencerManagerSequencerRemovedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// IEspressoRollupSequencerManagerSequencerRemoved represents a SequencerRemoved event raised by the IEspressoRollupSequencerManager contract.
+type IEspressoRollupSequencerManagerSequencerRemoved struct {
+	Sequencer common.Address
+	Nonce     *big.Int
+	Raw       types.Log // Blockchain specific contextual infos
+}
+
+// FilterSequencerRemoved is a free log retrieval operation binding the contract event 0x211a133ec451de7013a054ec41eb8fa07df65089fda546cbaa7a0cffa08375bc.
+//
+// Solidity: event SequencerRemoved(address indexed sequencer, uint256 indexed nonce)
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerFilterer) FilterSequencerRemoved(opts *bind.FilterOpts, sequencer []common.Address, nonce []*big.Int) (*IEspressoRollupSequencerManagerSequencerRemovedIterator, error) {
+
+	var sequencerRule []interface{}
+	for _, sequencerItem := range sequencer {
+		sequencerRule = append(sequencerRule, sequencerItem)
+	}
+	var nonceRule []interface{}
+	for _, nonceItem := range nonce {
+		nonceRule = append(nonceRule, nonceItem)
+	}
+
+	logs, sub, err := _IEspressoRollupSequencerManager.contract.FilterLogs(opts, "SequencerRemoved", sequencerRule, nonceRule)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoRollupSequencerManagerSequencerRemovedIterator{contract: _IEspressoRollupSequencerManager.contract, event: "SequencerRemoved", logs: logs, sub: sub}, nil
+}
+
+// WatchSequencerRemoved is a free log subscription operation binding the contract event 0x211a133ec451de7013a054ec41eb8fa07df65089fda546cbaa7a0cffa08375bc.
+//
+// Solidity: event SequencerRemoved(address indexed sequencer, uint256 indexed nonce)
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerFilterer) WatchSequencerRemoved(opts *bind.WatchOpts, sink chan<- *IEspressoRollupSequencerManagerSequencerRemoved, sequencer []common.Address, nonce []*big.Int) (event.Subscription, error) {
+
+	var sequencerRule []interface{}
+	for _, sequencerItem := range sequencer {
+		sequencerRule = append(sequencerRule, sequencerItem)
+	}
+	var nonceRule []interface{}
+	for _, nonceItem := range nonce {
+		nonceRule = append(nonceRule, nonceItem)
+	}
+
+	logs, sub, err := _IEspressoRollupSequencerManager.contract.WatchLogs(opts, "SequencerRemoved", sequencerRule, nonceRule)
+	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(IEspressoRollupSequencerManagerSequencerRemoved)
+				if err := _IEspressoRollupSequencerManager.contract.UnpackLog(event, "SequencerRemoved", 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
+}
+
+// ParseSequencerRemoved is a log parse operation binding the contract event 0x211a133ec451de7013a054ec41eb8fa07df65089fda546cbaa7a0cffa08375bc.
+//
+// Solidity: event SequencerRemoved(address indexed sequencer, uint256 indexed nonce)
+func (_IEspressoRollupSequencerManager *IEspressoRollupSequencerManagerFilterer) ParseSequencerRemoved(log types.Log) (*IEspressoRollupSequencerManagerSequencerRemoved, error) {
+	event := new(IEspressoRollupSequencerManagerSequencerRemoved)
+	if err := _IEspressoRollupSequencerManager.contract.UnpackLog(event, "SequencerRemoved", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// IEspressoSGXTEEVerifierMetaData contains all meta data concerning the IEspressoSGXTEEVerifier contract.
+var IEspressoSGXTEEVerifierMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"signers\",\"type\":\"address[]\"}],\"name\":\"deleteRegisteredSigners\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"rawEnclaveReport\",\"type\":\"bytes\"}],\"name\":\"parseEnclaveReport\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"bytes16\",\"name\":\"cpuSvn\",\"type\":\"bytes16\"},{\"internalType\":\"bytes4\",\"name\":\"miscSelect\",\"type\":\"bytes4\"},{\"internalType\":\"bytes28\",\"name\":\"reserved1\",\"type\":\"bytes28\"},{\"internalType\":\"bytes16\",\"name\":\"attributes\",\"type\":\"bytes16\"},{\"internalType\":\"bytes32\",\"name\":\"mrEnclave\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"reserved2\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"mrSigner\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"reserved3\",\"type\":\"bytes\"},{\"internalType\":\"uint16\",\"name\":\"isvProdId\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"isvSvn\",\"type\":\"uint16\"},{\"internalType\":\"bytes\",\"name\":\"reserved4\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"reportData\",\"type\":\"bytes\"}],\"internalType\":\"structEnclaveReport\",\"name\":\"enclaveReport\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"rawQuote\",\"type\":\"bytes\"}],\"name\":\"parseQuoteHeader\",\"outputs\":[{\"components\":[{\"internalType\":\"uint16\",\"name\":\"version\",\"type\":\"uint16\"},{\"internalType\":\"bytes2\",\"name\":\"attestationKeyType\",\"type\":\"bytes2\"},{\"internalType\":\"bytes4\",\"name\":\"teeType\",\"type\":\"bytes4\"},{\"internalType\":\"bytes2\",\"name\":\"qeSvn\",\"type\":\"bytes2\"},{\"internalType\":\"bytes2\",\"name\":\"pceSvn\",\"type\":\"bytes2\"},{\"internalType\":\"bytes16\",\"name\":\"qeVendorId\",\"type\":\"bytes16\"},{\"internalType\":\"bytes20\",\"name\":\"userData\",\"type\":\"bytes20\"}],\"internalType\":\"structHeader\",\"name\":\"header\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"attestation\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"registerSigner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"}],\"name\":\"registeredEnclaveHash\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"registeredSigners\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"},{\"internalType\":\"bool\",\"name\":\"valid\",\"type\":\"bool\"}],\"name\":\"setEnclaveHash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"rawQuote\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"reportDataHash\",\"type\":\"bytes32\"}],\"name\":\"verify\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes16\",\"name\":\"cpuSvn\",\"type\":\"bytes16\"},{\"internalType\":\"bytes4\",\"name\":\"miscSelect\",\"type\":\"bytes4\"},{\"internalType\":\"bytes28\",\"name\":\"reserved1\",\"type\":\"bytes28\"},{\"internalType\":\"bytes16\",\"name\":\"attributes\",\"type\":\"bytes16\"},{\"internalType\":\"bytes32\",\"name\":\"mrEnclave\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"reserved2\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"mrSigner\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"reserved3\",\"type\":\"bytes\"},{\"internalType\":\"uint16\",\"name\":\"isvProdId\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"isvSvn\",\"type\":\"uint16\"},{\"internalType\":\"bytes\",\"name\":\"reserved4\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"reportData\",\"type\":\"bytes\"}],\"internalType\":\"structEnclaveReport\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"DeletedRegisteredSigner\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"valid\",\"type\":\"bool\"}],\"name\":\"EnclaveHashSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"}],\"name\":\"SignerRegistered\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FailedToParseEnclaveReport\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidDataLength\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidEnclaveHash\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidHeaderVersion\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidQuote\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidQuoteVerifierAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidReportDataHash\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignerAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReportDataTooShort\",\"type\":\"error\"}]",
+}
+
+// IEspressoSGXTEEVerifierABI is the input ABI used to generate the binding from.
+// Deprecated: Use IEspressoSGXTEEVerifierMetaData.ABI instead.
+var IEspressoSGXTEEVerifierABI = IEspressoSGXTEEVerifierMetaData.ABI
+
+// IEspressoSGXTEEVerifier is an auto generated Go binding around an Ethereum contract.
+type IEspressoSGXTEEVerifier struct {
+	IEspressoSGXTEEVerifierCaller     // Read-only binding to the contract
+	IEspressoSGXTEEVerifierTransactor // Write-only binding to the contract
+	IEspressoSGXTEEVerifierFilterer   // Log filterer for contract events
+}
+
+// IEspressoSGXTEEVerifierCaller is an auto generated read-only Go binding around an Ethereum contract.
+type IEspressoSGXTEEVerifierCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IEspressoSGXTEEVerifierTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type IEspressoSGXTEEVerifierTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IEspressoSGXTEEVerifierFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type IEspressoSGXTEEVerifierFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IEspressoSGXTEEVerifierSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type IEspressoSGXTEEVerifierSession struct {
+	Contract     *IEspressoSGXTEEVerifier // 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
+}
+
+// IEspressoSGXTEEVerifierCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type IEspressoSGXTEEVerifierCallerSession struct {
+	Contract *IEspressoSGXTEEVerifierCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts                  // Call options to use throughout this session
+}
+
+// IEspressoSGXTEEVerifierTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type IEspressoSGXTEEVerifierTransactorSession struct {
+	Contract     *IEspressoSGXTEEVerifierTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts                  // Transaction auth options to use throughout this session
+}
+
+// IEspressoSGXTEEVerifierRaw is an auto generated low-level Go binding around an Ethereum contract.
+type IEspressoSGXTEEVerifierRaw struct {
+	Contract *IEspressoSGXTEEVerifier // Generic contract binding to access the raw methods on
+}
+
+// IEspressoSGXTEEVerifierCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type IEspressoSGXTEEVerifierCallerRaw struct {
+	Contract *IEspressoSGXTEEVerifierCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// IEspressoSGXTEEVerifierTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type IEspressoSGXTEEVerifierTransactorRaw struct {
+	Contract *IEspressoSGXTEEVerifierTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewIEspressoSGXTEEVerifier creates a new instance of IEspressoSGXTEEVerifier, bound to a specific deployed contract.
+func NewIEspressoSGXTEEVerifier(address common.Address, backend bind.ContractBackend) (*IEspressoSGXTEEVerifier, error) {
+	contract, err := bindIEspressoSGXTEEVerifier(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoSGXTEEVerifier{IEspressoSGXTEEVerifierCaller: IEspressoSGXTEEVerifierCaller{contract: contract}, IEspressoSGXTEEVerifierTransactor: IEspressoSGXTEEVerifierTransactor{contract: contract}, IEspressoSGXTEEVerifierFilterer: IEspressoSGXTEEVerifierFilterer{contract: contract}}, nil
+}
+
+// NewIEspressoSGXTEEVerifierCaller creates a new read-only instance of IEspressoSGXTEEVerifier, bound to a specific deployed contract.
+func NewIEspressoSGXTEEVerifierCaller(address common.Address, caller bind.ContractCaller) (*IEspressoSGXTEEVerifierCaller, error) {
+	contract, err := bindIEspressoSGXTEEVerifier(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoSGXTEEVerifierCaller{contract: contract}, nil
+}
+
+// NewIEspressoSGXTEEVerifierTransactor creates a new write-only instance of IEspressoSGXTEEVerifier, bound to a specific deployed contract.
+func NewIEspressoSGXTEEVerifierTransactor(address common.Address, transactor bind.ContractTransactor) (*IEspressoSGXTEEVerifierTransactor, error) {
+	contract, err := bindIEspressoSGXTEEVerifier(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoSGXTEEVerifierTransactor{contract: contract}, nil
+}
+
+// NewIEspressoSGXTEEVerifierFilterer creates a new log filterer instance of IEspressoSGXTEEVerifier, bound to a specific deployed contract.
+func NewIEspressoSGXTEEVerifierFilterer(address common.Address, filterer bind.ContractFilterer) (*IEspressoSGXTEEVerifierFilterer, error) {
+	contract, err := bindIEspressoSGXTEEVerifier(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoSGXTEEVerifierFilterer{contract: contract}, nil
+}
+
+// bindIEspressoSGXTEEVerifier binds a generic wrapper to an already deployed contract.
+func bindIEspressoSGXTEEVerifier(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := IEspressoSGXTEEVerifierMetaData.GetAbi()
+	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 (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IEspressoSGXTEEVerifier.Contract.IEspressoSGXTEEVerifierCaller.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 (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IEspressoSGXTEEVerifier.Contract.IEspressoSGXTEEVerifierTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IEspressoSGXTEEVerifier.Contract.IEspressoSGXTEEVerifierTransactor.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 (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IEspressoSGXTEEVerifier.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 (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IEspressoSGXTEEVerifier.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IEspressoSGXTEEVerifier.Contract.contract.Transact(opts, method, params...)
+}
+
+// ParseEnclaveReport is a free data retrieval call binding the contract method 0x78df6dde.
+//
+// Solidity: function parseEnclaveReport(bytes rawEnclaveReport) pure returns(bool success, (bytes16,bytes4,bytes28,bytes16,bytes32,bytes32,bytes32,bytes,uint16,uint16,bytes,bytes) enclaveReport)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierCaller) ParseEnclaveReport(opts *bind.CallOpts, rawEnclaveReport []byte) (struct {
+	Success       bool
+	EnclaveReport EnclaveReport
+}, error) {
+	var out []interface{}
+	err := _IEspressoSGXTEEVerifier.contract.Call(opts, &out, "parseEnclaveReport", rawEnclaveReport)
+
+	outstruct := new(struct {
+		Success       bool
+		EnclaveReport EnclaveReport
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.Success = *abi.ConvertType(out[0], new(bool)).(*bool)
+	outstruct.EnclaveReport = *abi.ConvertType(out[1], new(EnclaveReport)).(*EnclaveReport)
+
+	return *outstruct, err
+
+}
+
+// ParseEnclaveReport is a free data retrieval call binding the contract method 0x78df6dde.
+//
+// Solidity: function parseEnclaveReport(bytes rawEnclaveReport) pure returns(bool success, (bytes16,bytes4,bytes28,bytes16,bytes32,bytes32,bytes32,bytes,uint16,uint16,bytes,bytes) enclaveReport)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierSession) ParseEnclaveReport(rawEnclaveReport []byte) (struct {
+	Success       bool
+	EnclaveReport EnclaveReport
+}, error) {
+	return _IEspressoSGXTEEVerifier.Contract.ParseEnclaveReport(&_IEspressoSGXTEEVerifier.CallOpts, rawEnclaveReport)
+}
+
+// ParseEnclaveReport is a free data retrieval call binding the contract method 0x78df6dde.
+//
+// Solidity: function parseEnclaveReport(bytes rawEnclaveReport) pure returns(bool success, (bytes16,bytes4,bytes28,bytes16,bytes32,bytes32,bytes32,bytes,uint16,uint16,bytes,bytes) enclaveReport)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierCallerSession) ParseEnclaveReport(rawEnclaveReport []byte) (struct {
+	Success       bool
+	EnclaveReport EnclaveReport
+}, error) {
+	return _IEspressoSGXTEEVerifier.Contract.ParseEnclaveReport(&_IEspressoSGXTEEVerifier.CallOpts, rawEnclaveReport)
+}
+
+// ParseQuoteHeader is a free data retrieval call binding the contract method 0x7ac17b51.
+//
+// Solidity: function parseQuoteHeader(bytes rawQuote) pure returns((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) header)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierCaller) ParseQuoteHeader(opts *bind.CallOpts, rawQuote []byte) (Header, error) {
+	var out []interface{}
+	err := _IEspressoSGXTEEVerifier.contract.Call(opts, &out, "parseQuoteHeader", rawQuote)
+
+	if err != nil {
+		return *new(Header), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(Header)).(*Header)
+
+	return out0, err
+
+}
+
+// ParseQuoteHeader is a free data retrieval call binding the contract method 0x7ac17b51.
+//
+// Solidity: function parseQuoteHeader(bytes rawQuote) pure returns((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) header)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierSession) ParseQuoteHeader(rawQuote []byte) (Header, error) {
+	return _IEspressoSGXTEEVerifier.Contract.ParseQuoteHeader(&_IEspressoSGXTEEVerifier.CallOpts, rawQuote)
+}
+
+// ParseQuoteHeader is a free data retrieval call binding the contract method 0x7ac17b51.
+//
+// Solidity: function parseQuoteHeader(bytes rawQuote) pure returns((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) header)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierCallerSession) ParseQuoteHeader(rawQuote []byte) (Header, error) {
+	return _IEspressoSGXTEEVerifier.Contract.ParseQuoteHeader(&_IEspressoSGXTEEVerifier.CallOpts, rawQuote)
+}
+
+// RegisteredEnclaveHash is a free data retrieval call binding the contract method 0x966989ee.
+//
+// Solidity: function registeredEnclaveHash(bytes32 enclaveHash) view returns(bool)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierCaller) RegisteredEnclaveHash(opts *bind.CallOpts, enclaveHash [32]byte) (bool, error) {
+	var out []interface{}
+	err := _IEspressoSGXTEEVerifier.contract.Call(opts, &out, "registeredEnclaveHash", enclaveHash)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredEnclaveHash is a free data retrieval call binding the contract method 0x966989ee.
+//
+// Solidity: function registeredEnclaveHash(bytes32 enclaveHash) view returns(bool)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierSession) RegisteredEnclaveHash(enclaveHash [32]byte) (bool, error) {
+	return _IEspressoSGXTEEVerifier.Contract.RegisteredEnclaveHash(&_IEspressoSGXTEEVerifier.CallOpts, enclaveHash)
+}
+
+// RegisteredEnclaveHash is a free data retrieval call binding the contract method 0x966989ee.
+//
+// Solidity: function registeredEnclaveHash(bytes32 enclaveHash) view returns(bool)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierCallerSession) RegisteredEnclaveHash(enclaveHash [32]byte) (bool, error) {
+	return _IEspressoSGXTEEVerifier.Contract.RegisteredEnclaveHash(&_IEspressoSGXTEEVerifier.CallOpts, enclaveHash)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0x0123d0c1.
+//
+// Solidity: function registeredSigners(address signer) view returns(bool)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierCaller) RegisteredSigners(opts *bind.CallOpts, signer common.Address) (bool, error) {
+	var out []interface{}
+	err := _IEspressoSGXTEEVerifier.contract.Call(opts, &out, "registeredSigners", signer)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0x0123d0c1.
+//
+// Solidity: function registeredSigners(address signer) view returns(bool)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierSession) RegisteredSigners(signer common.Address) (bool, error) {
+	return _IEspressoSGXTEEVerifier.Contract.RegisteredSigners(&_IEspressoSGXTEEVerifier.CallOpts, signer)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0x0123d0c1.
+//
+// Solidity: function registeredSigners(address signer) view returns(bool)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierCallerSession) RegisteredSigners(signer common.Address) (bool, error) {
+	return _IEspressoSGXTEEVerifier.Contract.RegisteredSigners(&_IEspressoSGXTEEVerifier.CallOpts, signer)
+}
+
+// Verify is a free data retrieval call binding the contract method 0x6b406341.
+//
+// Solidity: function verify(bytes rawQuote, bytes32 reportDataHash) view returns((bytes16,bytes4,bytes28,bytes16,bytes32,bytes32,bytes32,bytes,uint16,uint16,bytes,bytes))
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierCaller) Verify(opts *bind.CallOpts, rawQuote []byte, reportDataHash [32]byte) (EnclaveReport, error) {
+	var out []interface{}
+	err := _IEspressoSGXTEEVerifier.contract.Call(opts, &out, "verify", rawQuote, reportDataHash)
+
+	if err != nil {
+		return *new(EnclaveReport), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(EnclaveReport)).(*EnclaveReport)
+
+	return out0, err
+
+}
+
+// Verify is a free data retrieval call binding the contract method 0x6b406341.
+//
+// Solidity: function verify(bytes rawQuote, bytes32 reportDataHash) view returns((bytes16,bytes4,bytes28,bytes16,bytes32,bytes32,bytes32,bytes,uint16,uint16,bytes,bytes))
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierSession) Verify(rawQuote []byte, reportDataHash [32]byte) (EnclaveReport, error) {
+	return _IEspressoSGXTEEVerifier.Contract.Verify(&_IEspressoSGXTEEVerifier.CallOpts, rawQuote, reportDataHash)
+}
+
+// Verify is a free data retrieval call binding the contract method 0x6b406341.
+//
+// Solidity: function verify(bytes rawQuote, bytes32 reportDataHash) view returns((bytes16,bytes4,bytes28,bytes16,bytes32,bytes32,bytes32,bytes,uint16,uint16,bytes,bytes))
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierCallerSession) Verify(rawQuote []byte, reportDataHash [32]byte) (EnclaveReport, error) {
+	return _IEspressoSGXTEEVerifier.Contract.Verify(&_IEspressoSGXTEEVerifier.CallOpts, rawQuote, reportDataHash)
+}
+
+// DeleteRegisteredSigners is a paid mutator transaction binding the contract method 0xe7370be0.
+//
+// Solidity: function deleteRegisteredSigners(address[] signers) returns()
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierTransactor) DeleteRegisteredSigners(opts *bind.TransactOpts, signers []common.Address) (*types.Transaction, error) {
+	return _IEspressoSGXTEEVerifier.contract.Transact(opts, "deleteRegisteredSigners", signers)
+}
+
+// DeleteRegisteredSigners is a paid mutator transaction binding the contract method 0xe7370be0.
+//
+// Solidity: function deleteRegisteredSigners(address[] signers) returns()
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierSession) DeleteRegisteredSigners(signers []common.Address) (*types.Transaction, error) {
+	return _IEspressoSGXTEEVerifier.Contract.DeleteRegisteredSigners(&_IEspressoSGXTEEVerifier.TransactOpts, signers)
+}
+
+// DeleteRegisteredSigners is a paid mutator transaction binding the contract method 0xe7370be0.
+//
+// Solidity: function deleteRegisteredSigners(address[] signers) returns()
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierTransactorSession) DeleteRegisteredSigners(signers []common.Address) (*types.Transaction, error) {
+	return _IEspressoSGXTEEVerifier.Contract.DeleteRegisteredSigners(&_IEspressoSGXTEEVerifier.TransactOpts, signers)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0xba58e82a.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data) returns()
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierTransactor) RegisterSigner(opts *bind.TransactOpts, attestation []byte, data []byte) (*types.Transaction, error) {
+	return _IEspressoSGXTEEVerifier.contract.Transact(opts, "registerSigner", attestation, data)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0xba58e82a.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data) returns()
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierSession) RegisterSigner(attestation []byte, data []byte) (*types.Transaction, error) {
+	return _IEspressoSGXTEEVerifier.Contract.RegisterSigner(&_IEspressoSGXTEEVerifier.TransactOpts, attestation, data)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0xba58e82a.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data) returns()
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierTransactorSession) RegisterSigner(attestation []byte, data []byte) (*types.Transaction, error) {
+	return _IEspressoSGXTEEVerifier.Contract.RegisterSigner(&_IEspressoSGXTEEVerifier.TransactOpts, attestation, data)
+}
+
+// SetEnclaveHash is a paid mutator transaction binding the contract method 0x93b5552e.
+//
+// Solidity: function setEnclaveHash(bytes32 enclaveHash, bool valid) returns()
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierTransactor) SetEnclaveHash(opts *bind.TransactOpts, enclaveHash [32]byte, valid bool) (*types.Transaction, error) {
+	return _IEspressoSGXTEEVerifier.contract.Transact(opts, "setEnclaveHash", enclaveHash, valid)
+}
+
+// SetEnclaveHash is a paid mutator transaction binding the contract method 0x93b5552e.
+//
+// Solidity: function setEnclaveHash(bytes32 enclaveHash, bool valid) returns()
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierSession) SetEnclaveHash(enclaveHash [32]byte, valid bool) (*types.Transaction, error) {
+	return _IEspressoSGXTEEVerifier.Contract.SetEnclaveHash(&_IEspressoSGXTEEVerifier.TransactOpts, enclaveHash, valid)
+}
+
+// SetEnclaveHash is a paid mutator transaction binding the contract method 0x93b5552e.
+//
+// Solidity: function setEnclaveHash(bytes32 enclaveHash, bool valid) returns()
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierTransactorSession) SetEnclaveHash(enclaveHash [32]byte, valid bool) (*types.Transaction, error) {
+	return _IEspressoSGXTEEVerifier.Contract.SetEnclaveHash(&_IEspressoSGXTEEVerifier.TransactOpts, enclaveHash, valid)
+}
+
+// IEspressoSGXTEEVerifierDeletedRegisteredSignerIterator is returned from FilterDeletedRegisteredSigner and is used to iterate over the raw logs and unpacked data for DeletedRegisteredSigner events raised by the IEspressoSGXTEEVerifier contract.
+type IEspressoSGXTEEVerifierDeletedRegisteredSignerIterator struct {
+	Event *IEspressoSGXTEEVerifierDeletedRegisteredSigner // 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 *IEspressoSGXTEEVerifierDeletedRegisteredSignerIterator) 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(IEspressoSGXTEEVerifierDeletedRegisteredSigner)
+			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(IEspressoSGXTEEVerifierDeletedRegisteredSigner)
+		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 *IEspressoSGXTEEVerifierDeletedRegisteredSignerIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *IEspressoSGXTEEVerifierDeletedRegisteredSignerIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// IEspressoSGXTEEVerifierDeletedRegisteredSigner represents a DeletedRegisteredSigner event raised by the IEspressoSGXTEEVerifier contract.
+type IEspressoSGXTEEVerifierDeletedRegisteredSigner struct {
+	Signer common.Address
+	Raw    types.Log // Blockchain specific contextual infos
+}
+
+// FilterDeletedRegisteredSigner is a free log retrieval operation binding the contract event 0x4872495ab7a697b6ed37286c6738fc94eaf291e5e4908abc1e2b479894f002dd.
+//
+// Solidity: event DeletedRegisteredSigner(address signer)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierFilterer) FilterDeletedRegisteredSigner(opts *bind.FilterOpts) (*IEspressoSGXTEEVerifierDeletedRegisteredSignerIterator, error) {
+
+	logs, sub, err := _IEspressoSGXTEEVerifier.contract.FilterLogs(opts, "DeletedRegisteredSigner")
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoSGXTEEVerifierDeletedRegisteredSignerIterator{contract: _IEspressoSGXTEEVerifier.contract, event: "DeletedRegisteredSigner", logs: logs, sub: sub}, nil
+}
+
+// WatchDeletedRegisteredSigner is a free log subscription operation binding the contract event 0x4872495ab7a697b6ed37286c6738fc94eaf291e5e4908abc1e2b479894f002dd.
+//
+// Solidity: event DeletedRegisteredSigner(address signer)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierFilterer) WatchDeletedRegisteredSigner(opts *bind.WatchOpts, sink chan<- *IEspressoSGXTEEVerifierDeletedRegisteredSigner) (event.Subscription, error) {
+
+	logs, sub, err := _IEspressoSGXTEEVerifier.contract.WatchLogs(opts, "DeletedRegisteredSigner")
+	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(IEspressoSGXTEEVerifierDeletedRegisteredSigner)
+				if err := _IEspressoSGXTEEVerifier.contract.UnpackLog(event, "DeletedRegisteredSigner", 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
+}
+
+// ParseDeletedRegisteredSigner is a log parse operation binding the contract event 0x4872495ab7a697b6ed37286c6738fc94eaf291e5e4908abc1e2b479894f002dd.
+//
+// Solidity: event DeletedRegisteredSigner(address signer)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierFilterer) ParseDeletedRegisteredSigner(log types.Log) (*IEspressoSGXTEEVerifierDeletedRegisteredSigner, error) {
+	event := new(IEspressoSGXTEEVerifierDeletedRegisteredSigner)
+	if err := _IEspressoSGXTEEVerifier.contract.UnpackLog(event, "DeletedRegisteredSigner", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// IEspressoSGXTEEVerifierEnclaveHashSetIterator is returned from FilterEnclaveHashSet and is used to iterate over the raw logs and unpacked data for EnclaveHashSet events raised by the IEspressoSGXTEEVerifier contract.
+type IEspressoSGXTEEVerifierEnclaveHashSetIterator struct {
+	Event *IEspressoSGXTEEVerifierEnclaveHashSet // 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 *IEspressoSGXTEEVerifierEnclaveHashSetIterator) 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(IEspressoSGXTEEVerifierEnclaveHashSet)
+			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(IEspressoSGXTEEVerifierEnclaveHashSet)
+		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 *IEspressoSGXTEEVerifierEnclaveHashSetIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *IEspressoSGXTEEVerifierEnclaveHashSetIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// IEspressoSGXTEEVerifierEnclaveHashSet represents a EnclaveHashSet event raised by the IEspressoSGXTEEVerifier contract.
+type IEspressoSGXTEEVerifierEnclaveHashSet struct {
+	EnclaveHash [32]byte
+	Valid       bool
+	Raw         types.Log // Blockchain specific contextual infos
+}
+
+// FilterEnclaveHashSet is a free log retrieval operation binding the contract event 0x2282c24f65eac8254df1107716a961b677b872ed0e1d2a9f6bafc154441eb7fd.
+//
+// Solidity: event EnclaveHashSet(bytes32 enclaveHash, bool valid)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierFilterer) FilterEnclaveHashSet(opts *bind.FilterOpts) (*IEspressoSGXTEEVerifierEnclaveHashSetIterator, error) {
+
+	logs, sub, err := _IEspressoSGXTEEVerifier.contract.FilterLogs(opts, "EnclaveHashSet")
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoSGXTEEVerifierEnclaveHashSetIterator{contract: _IEspressoSGXTEEVerifier.contract, event: "EnclaveHashSet", logs: logs, sub: sub}, nil
+}
+
+// WatchEnclaveHashSet is a free log subscription operation binding the contract event 0x2282c24f65eac8254df1107716a961b677b872ed0e1d2a9f6bafc154441eb7fd.
+//
+// Solidity: event EnclaveHashSet(bytes32 enclaveHash, bool valid)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierFilterer) WatchEnclaveHashSet(opts *bind.WatchOpts, sink chan<- *IEspressoSGXTEEVerifierEnclaveHashSet) (event.Subscription, error) {
+
+	logs, sub, err := _IEspressoSGXTEEVerifier.contract.WatchLogs(opts, "EnclaveHashSet")
+	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(IEspressoSGXTEEVerifierEnclaveHashSet)
+				if err := _IEspressoSGXTEEVerifier.contract.UnpackLog(event, "EnclaveHashSet", 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
+}
+
+// ParseEnclaveHashSet is a log parse operation binding the contract event 0x2282c24f65eac8254df1107716a961b677b872ed0e1d2a9f6bafc154441eb7fd.
+//
+// Solidity: event EnclaveHashSet(bytes32 enclaveHash, bool valid)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierFilterer) ParseEnclaveHashSet(log types.Log) (*IEspressoSGXTEEVerifierEnclaveHashSet, error) {
+	event := new(IEspressoSGXTEEVerifierEnclaveHashSet)
+	if err := _IEspressoSGXTEEVerifier.contract.UnpackLog(event, "EnclaveHashSet", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// IEspressoSGXTEEVerifierSignerRegisteredIterator is returned from FilterSignerRegistered and is used to iterate over the raw logs and unpacked data for SignerRegistered events raised by the IEspressoSGXTEEVerifier contract.
+type IEspressoSGXTEEVerifierSignerRegisteredIterator struct {
+	Event *IEspressoSGXTEEVerifierSignerRegistered // 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 *IEspressoSGXTEEVerifierSignerRegisteredIterator) 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(IEspressoSGXTEEVerifierSignerRegistered)
+			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(IEspressoSGXTEEVerifierSignerRegistered)
+		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 *IEspressoSGXTEEVerifierSignerRegisteredIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *IEspressoSGXTEEVerifierSignerRegisteredIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// IEspressoSGXTEEVerifierSignerRegistered represents a SignerRegistered event raised by the IEspressoSGXTEEVerifier contract.
+type IEspressoSGXTEEVerifierSignerRegistered struct {
+	Signer      common.Address
+	EnclaveHash [32]byte
+	Raw         types.Log // Blockchain specific contextual infos
+}
+
+// FilterSignerRegistered is a free log retrieval operation binding the contract event 0xcf848c482fcf6fe3067875f261b92c8f20a9756538ee17b8ef66ad0b7bae208c.
+//
+// Solidity: event SignerRegistered(address signer, bytes32 enclaveHash)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierFilterer) FilterSignerRegistered(opts *bind.FilterOpts) (*IEspressoSGXTEEVerifierSignerRegisteredIterator, error) {
+
+	logs, sub, err := _IEspressoSGXTEEVerifier.contract.FilterLogs(opts, "SignerRegistered")
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoSGXTEEVerifierSignerRegisteredIterator{contract: _IEspressoSGXTEEVerifier.contract, event: "SignerRegistered", logs: logs, sub: sub}, nil
+}
+
+// WatchSignerRegistered is a free log subscription operation binding the contract event 0xcf848c482fcf6fe3067875f261b92c8f20a9756538ee17b8ef66ad0b7bae208c.
+//
+// Solidity: event SignerRegistered(address signer, bytes32 enclaveHash)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierFilterer) WatchSignerRegistered(opts *bind.WatchOpts, sink chan<- *IEspressoSGXTEEVerifierSignerRegistered) (event.Subscription, error) {
+
+	logs, sub, err := _IEspressoSGXTEEVerifier.contract.WatchLogs(opts, "SignerRegistered")
+	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(IEspressoSGXTEEVerifierSignerRegistered)
+				if err := _IEspressoSGXTEEVerifier.contract.UnpackLog(event, "SignerRegistered", 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
+}
+
+// ParseSignerRegistered is a log parse operation binding the contract event 0xcf848c482fcf6fe3067875f261b92c8f20a9756538ee17b8ef66ad0b7bae208c.
+//
+// Solidity: event SignerRegistered(address signer, bytes32 enclaveHash)
+func (_IEspressoSGXTEEVerifier *IEspressoSGXTEEVerifierFilterer) ParseSignerRegistered(log types.Log) (*IEspressoSGXTEEVerifierSignerRegistered, error) {
+	event := new(IEspressoSGXTEEVerifierSignerRegistered)
+	if err := _IEspressoSGXTEEVerifier.contract.UnpackLog(event, "SignerRegistered", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// IEspressoTEEVerifierMetaData contains all meta data concerning the IEspressoTEEVerifier contract.
+var IEspressoTEEVerifierMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"espressoNitroTEEVerifier\",\"outputs\":[{\"internalType\":\"contractIEspressoNitroTEEVerifier\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"espressoSGXTEEVerifier\",\"outputs\":[{\"internalType\":\"contractIEspressoSGXTEEVerifier\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"attestation\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"enumIEspressoTEEVerifier.TeeType\",\"name\":\"teeType\",\"type\":\"uint8\"}],\"name\":\"registerSigner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"enclaveHash\",\"type\":\"bytes32\"},{\"internalType\":\"enumIEspressoTEEVerifier.TeeType\",\"name\":\"teeType\",\"type\":\"uint8\"}],\"name\":\"registeredEnclaveHashes\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"enumIEspressoTEEVerifier.TeeType\",\"name\":\"teeType\",\"type\":\"uint8\"}],\"name\":\"registeredSigners\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractIEspressoNitroTEEVerifier\",\"name\":\"_espressoNitroTEEVerifier\",\"type\":\"address\"}],\"name\":\"setEspressoNitroTEEVerifier\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractIEspressoSGXTEEVerifier\",\"name\":\"_espressoSGXTEEVerifier\",\"type\":\"address\"}],\"name\":\"setEspressoSGXTEEVerifier\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"userDataHash\",\"type\":\"bytes32\"},{\"internalType\":\"enumIEspressoTEEVerifier.TeeType\",\"name\":\"teeType\",\"type\":\"uint8\"}],\"name\":\"verify\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnsupportedTeeType\",\"type\":\"error\"}]",
+}
+
+// IEspressoTEEVerifierABI is the input ABI used to generate the binding from.
+// Deprecated: Use IEspressoTEEVerifierMetaData.ABI instead.
+var IEspressoTEEVerifierABI = IEspressoTEEVerifierMetaData.ABI
+
+// IEspressoTEEVerifier is an auto generated Go binding around an Ethereum contract.
+type IEspressoTEEVerifier struct {
+	IEspressoTEEVerifierCaller     // Read-only binding to the contract
+	IEspressoTEEVerifierTransactor // Write-only binding to the contract
+	IEspressoTEEVerifierFilterer   // Log filterer for contract events
+}
+
+// IEspressoTEEVerifierCaller is an auto generated read-only Go binding around an Ethereum contract.
+type IEspressoTEEVerifierCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IEspressoTEEVerifierTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type IEspressoTEEVerifierTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IEspressoTEEVerifierFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type IEspressoTEEVerifierFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IEspressoTEEVerifierSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type IEspressoTEEVerifierSession struct {
+	Contract     *IEspressoTEEVerifier // 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
+}
+
+// IEspressoTEEVerifierCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type IEspressoTEEVerifierCallerSession struct {
+	Contract *IEspressoTEEVerifierCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts               // Call options to use throughout this session
+}
+
+// IEspressoTEEVerifierTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type IEspressoTEEVerifierTransactorSession struct {
+	Contract     *IEspressoTEEVerifierTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts               // Transaction auth options to use throughout this session
+}
+
+// IEspressoTEEVerifierRaw is an auto generated low-level Go binding around an Ethereum contract.
+type IEspressoTEEVerifierRaw struct {
+	Contract *IEspressoTEEVerifier // Generic contract binding to access the raw methods on
+}
+
+// IEspressoTEEVerifierCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type IEspressoTEEVerifierCallerRaw struct {
+	Contract *IEspressoTEEVerifierCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// IEspressoTEEVerifierTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type IEspressoTEEVerifierTransactorRaw struct {
+	Contract *IEspressoTEEVerifierTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewIEspressoTEEVerifier creates a new instance of IEspressoTEEVerifier, bound to a specific deployed contract.
+func NewIEspressoTEEVerifier(address common.Address, backend bind.ContractBackend) (*IEspressoTEEVerifier, error) {
+	contract, err := bindIEspressoTEEVerifier(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoTEEVerifier{IEspressoTEEVerifierCaller: IEspressoTEEVerifierCaller{contract: contract}, IEspressoTEEVerifierTransactor: IEspressoTEEVerifierTransactor{contract: contract}, IEspressoTEEVerifierFilterer: IEspressoTEEVerifierFilterer{contract: contract}}, nil
+}
+
+// NewIEspressoTEEVerifierCaller creates a new read-only instance of IEspressoTEEVerifier, bound to a specific deployed contract.
+func NewIEspressoTEEVerifierCaller(address common.Address, caller bind.ContractCaller) (*IEspressoTEEVerifierCaller, error) {
+	contract, err := bindIEspressoTEEVerifier(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoTEEVerifierCaller{contract: contract}, nil
+}
+
+// NewIEspressoTEEVerifierTransactor creates a new write-only instance of IEspressoTEEVerifier, bound to a specific deployed contract.
+func NewIEspressoTEEVerifierTransactor(address common.Address, transactor bind.ContractTransactor) (*IEspressoTEEVerifierTransactor, error) {
+	contract, err := bindIEspressoTEEVerifier(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoTEEVerifierTransactor{contract: contract}, nil
+}
+
+// NewIEspressoTEEVerifierFilterer creates a new log filterer instance of IEspressoTEEVerifier, bound to a specific deployed contract.
+func NewIEspressoTEEVerifierFilterer(address common.Address, filterer bind.ContractFilterer) (*IEspressoTEEVerifierFilterer, error) {
+	contract, err := bindIEspressoTEEVerifier(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &IEspressoTEEVerifierFilterer{contract: contract}, nil
+}
+
+// bindIEspressoTEEVerifier binds a generic wrapper to an already deployed contract.
+func bindIEspressoTEEVerifier(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := IEspressoTEEVerifierMetaData.GetAbi()
+	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 (_IEspressoTEEVerifier *IEspressoTEEVerifierRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IEspressoTEEVerifier.Contract.IEspressoTEEVerifierCaller.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 (_IEspressoTEEVerifier *IEspressoTEEVerifierRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IEspressoTEEVerifier.Contract.IEspressoTEEVerifierTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IEspressoTEEVerifier.Contract.IEspressoTEEVerifierTransactor.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 (_IEspressoTEEVerifier *IEspressoTEEVerifierCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IEspressoTEEVerifier.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 (_IEspressoTEEVerifier *IEspressoTEEVerifierTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IEspressoTEEVerifier.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IEspressoTEEVerifier.Contract.contract.Transact(opts, method, params...)
+}
+
+// EspressoNitroTEEVerifier is a free data retrieval call binding the contract method 0xd80a4c28.
+//
+// Solidity: function espressoNitroTEEVerifier() view returns(address)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierCaller) EspressoNitroTEEVerifier(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _IEspressoTEEVerifier.contract.Call(opts, &out, "espressoNitroTEEVerifier")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// EspressoNitroTEEVerifier is a free data retrieval call binding the contract method 0xd80a4c28.
+//
+// Solidity: function espressoNitroTEEVerifier() view returns(address)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierSession) EspressoNitroTEEVerifier() (common.Address, error) {
+	return _IEspressoTEEVerifier.Contract.EspressoNitroTEEVerifier(&_IEspressoTEEVerifier.CallOpts)
+}
+
+// EspressoNitroTEEVerifier is a free data retrieval call binding the contract method 0xd80a4c28.
+//
+// Solidity: function espressoNitroTEEVerifier() view returns(address)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierCallerSession) EspressoNitroTEEVerifier() (common.Address, error) {
+	return _IEspressoTEEVerifier.Contract.EspressoNitroTEEVerifier(&_IEspressoTEEVerifier.CallOpts)
+}
+
+// EspressoSGXTEEVerifier is a free data retrieval call binding the contract method 0x80710c80.
+//
+// Solidity: function espressoSGXTEEVerifier() view returns(address)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierCaller) EspressoSGXTEEVerifier(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _IEspressoTEEVerifier.contract.Call(opts, &out, "espressoSGXTEEVerifier")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// EspressoSGXTEEVerifier is a free data retrieval call binding the contract method 0x80710c80.
+//
+// Solidity: function espressoSGXTEEVerifier() view returns(address)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierSession) EspressoSGXTEEVerifier() (common.Address, error) {
+	return _IEspressoTEEVerifier.Contract.EspressoSGXTEEVerifier(&_IEspressoTEEVerifier.CallOpts)
+}
+
+// EspressoSGXTEEVerifier is a free data retrieval call binding the contract method 0x80710c80.
+//
+// Solidity: function espressoSGXTEEVerifier() view returns(address)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierCallerSession) EspressoSGXTEEVerifier() (common.Address, error) {
+	return _IEspressoTEEVerifier.Contract.EspressoSGXTEEVerifier(&_IEspressoTEEVerifier.CallOpts)
+}
+
+// RegisteredEnclaveHashes is a free data retrieval call binding the contract method 0x3cbe6803.
+//
+// Solidity: function registeredEnclaveHashes(bytes32 enclaveHash, uint8 teeType) view returns(bool)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierCaller) RegisteredEnclaveHashes(opts *bind.CallOpts, enclaveHash [32]byte, teeType uint8) (bool, error) {
+	var out []interface{}
+	err := _IEspressoTEEVerifier.contract.Call(opts, &out, "registeredEnclaveHashes", enclaveHash, teeType)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredEnclaveHashes is a free data retrieval call binding the contract method 0x3cbe6803.
+//
+// Solidity: function registeredEnclaveHashes(bytes32 enclaveHash, uint8 teeType) view returns(bool)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierSession) RegisteredEnclaveHashes(enclaveHash [32]byte, teeType uint8) (bool, error) {
+	return _IEspressoTEEVerifier.Contract.RegisteredEnclaveHashes(&_IEspressoTEEVerifier.CallOpts, enclaveHash, teeType)
+}
+
+// RegisteredEnclaveHashes is a free data retrieval call binding the contract method 0x3cbe6803.
+//
+// Solidity: function registeredEnclaveHashes(bytes32 enclaveHash, uint8 teeType) view returns(bool)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierCallerSession) RegisteredEnclaveHashes(enclaveHash [32]byte, teeType uint8) (bool, error) {
+	return _IEspressoTEEVerifier.Contract.RegisteredEnclaveHashes(&_IEspressoTEEVerifier.CallOpts, enclaveHash, teeType)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0xe9b1a7be.
+//
+// Solidity: function registeredSigners(address signer, uint8 teeType) view returns(bool)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierCaller) RegisteredSigners(opts *bind.CallOpts, signer common.Address, teeType uint8) (bool, error) {
+	var out []interface{}
+	err := _IEspressoTEEVerifier.contract.Call(opts, &out, "registeredSigners", signer, teeType)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0xe9b1a7be.
+//
+// Solidity: function registeredSigners(address signer, uint8 teeType) view returns(bool)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierSession) RegisteredSigners(signer common.Address, teeType uint8) (bool, error) {
+	return _IEspressoTEEVerifier.Contract.RegisteredSigners(&_IEspressoTEEVerifier.CallOpts, signer, teeType)
+}
+
+// RegisteredSigners is a free data retrieval call binding the contract method 0xe9b1a7be.
+//
+// Solidity: function registeredSigners(address signer, uint8 teeType) view returns(bool)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierCallerSession) RegisteredSigners(signer common.Address, teeType uint8) (bool, error) {
+	return _IEspressoTEEVerifier.Contract.RegisteredSigners(&_IEspressoTEEVerifier.CallOpts, signer, teeType)
+}
+
+// Verify is a free data retrieval call binding the contract method 0xa81d9c5c.
+//
+// Solidity: function verify(bytes signature, bytes32 userDataHash, uint8 teeType) view returns(bool)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierCaller) Verify(opts *bind.CallOpts, signature []byte, userDataHash [32]byte, teeType uint8) (bool, error) {
+	var out []interface{}
+	err := _IEspressoTEEVerifier.contract.Call(opts, &out, "verify", signature, userDataHash, teeType)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// Verify is a free data retrieval call binding the contract method 0xa81d9c5c.
+//
+// Solidity: function verify(bytes signature, bytes32 userDataHash, uint8 teeType) view returns(bool)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierSession) Verify(signature []byte, userDataHash [32]byte, teeType uint8) (bool, error) {
+	return _IEspressoTEEVerifier.Contract.Verify(&_IEspressoTEEVerifier.CallOpts, signature, userDataHash, teeType)
+}
+
+// Verify is a free data retrieval call binding the contract method 0xa81d9c5c.
+//
+// Solidity: function verify(bytes signature, bytes32 userDataHash, uint8 teeType) view returns(bool)
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierCallerSession) Verify(signature []byte, userDataHash [32]byte, teeType uint8) (bool, error) {
+	return _IEspressoTEEVerifier.Contract.Verify(&_IEspressoTEEVerifier.CallOpts, signature, userDataHash, teeType)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0x35ecb4c1.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data, uint8 teeType) returns()
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierTransactor) RegisterSigner(opts *bind.TransactOpts, attestation []byte, data []byte, teeType uint8) (*types.Transaction, error) {
+	return _IEspressoTEEVerifier.contract.Transact(opts, "registerSigner", attestation, data, teeType)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0x35ecb4c1.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data, uint8 teeType) returns()
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierSession) RegisterSigner(attestation []byte, data []byte, teeType uint8) (*types.Transaction, error) {
+	return _IEspressoTEEVerifier.Contract.RegisterSigner(&_IEspressoTEEVerifier.TransactOpts, attestation, data, teeType)
+}
+
+// RegisterSigner is a paid mutator transaction binding the contract method 0x35ecb4c1.
+//
+// Solidity: function registerSigner(bytes attestation, bytes data, uint8 teeType) returns()
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierTransactorSession) RegisterSigner(attestation []byte, data []byte, teeType uint8) (*types.Transaction, error) {
+	return _IEspressoTEEVerifier.Contract.RegisterSigner(&_IEspressoTEEVerifier.TransactOpts, attestation, data, teeType)
+}
+
+// SetEspressoNitroTEEVerifier is a paid mutator transaction binding the contract method 0x330282f5.
+//
+// Solidity: function setEspressoNitroTEEVerifier(address _espressoNitroTEEVerifier) returns()
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierTransactor) SetEspressoNitroTEEVerifier(opts *bind.TransactOpts, _espressoNitroTEEVerifier common.Address) (*types.Transaction, error) {
+	return _IEspressoTEEVerifier.contract.Transact(opts, "setEspressoNitroTEEVerifier", _espressoNitroTEEVerifier)
+}
+
+// SetEspressoNitroTEEVerifier is a paid mutator transaction binding the contract method 0x330282f5.
+//
+// Solidity: function setEspressoNitroTEEVerifier(address _espressoNitroTEEVerifier) returns()
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierSession) SetEspressoNitroTEEVerifier(_espressoNitroTEEVerifier common.Address) (*types.Transaction, error) {
+	return _IEspressoTEEVerifier.Contract.SetEspressoNitroTEEVerifier(&_IEspressoTEEVerifier.TransactOpts, _espressoNitroTEEVerifier)
+}
+
+// SetEspressoNitroTEEVerifier is a paid mutator transaction binding the contract method 0x330282f5.
+//
+// Solidity: function setEspressoNitroTEEVerifier(address _espressoNitroTEEVerifier) returns()
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierTransactorSession) SetEspressoNitroTEEVerifier(_espressoNitroTEEVerifier common.Address) (*types.Transaction, error) {
+	return _IEspressoTEEVerifier.Contract.SetEspressoNitroTEEVerifier(&_IEspressoTEEVerifier.TransactOpts, _espressoNitroTEEVerifier)
+}
+
+// SetEspressoSGXTEEVerifier is a paid mutator transaction binding the contract method 0xbc3a0911.
+//
+// Solidity: function setEspressoSGXTEEVerifier(address _espressoSGXTEEVerifier) returns()
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierTransactor) SetEspressoSGXTEEVerifier(opts *bind.TransactOpts, _espressoSGXTEEVerifier common.Address) (*types.Transaction, error) {
+	return _IEspressoTEEVerifier.contract.Transact(opts, "setEspressoSGXTEEVerifier", _espressoSGXTEEVerifier)
+}
+
+// SetEspressoSGXTEEVerifier is a paid mutator transaction binding the contract method 0xbc3a0911.
+//
+// Solidity: function setEspressoSGXTEEVerifier(address _espressoSGXTEEVerifier) returns()
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierSession) SetEspressoSGXTEEVerifier(_espressoSGXTEEVerifier common.Address) (*types.Transaction, error) {
+	return _IEspressoTEEVerifier.Contract.SetEspressoSGXTEEVerifier(&_IEspressoTEEVerifier.TransactOpts, _espressoSGXTEEVerifier)
+}
+
+// SetEspressoSGXTEEVerifier is a paid mutator transaction binding the contract method 0xbc3a0911.
+//
+// Solidity: function setEspressoSGXTEEVerifier(address _espressoSGXTEEVerifier) returns()
+func (_IEspressoTEEVerifier *IEspressoTEEVerifierTransactorSession) SetEspressoSGXTEEVerifier(_espressoSGXTEEVerifier common.Address) (*types.Transaction, error) {
+	return _IEspressoTEEVerifier.Contract.SetEspressoSGXTEEVerifier(&_IEspressoTEEVerifier.TransactOpts, _espressoSGXTEEVerifier)
+}
+
+// IMulticall3MetaData contains all meta data concerning the IMulticall3 contract.
+var IMulticall3MetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Call[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"aggregate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"},{\"internalType\":\"bytes[]\",\"name\":\"returnData\",\"type\":\"bytes[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"allowFailure\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Call3[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"aggregate3\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Result[]\",\"name\":\"returnData\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"allowFailure\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Call3Value[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"aggregate3Value\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Result[]\",\"name\":\"returnData\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Call[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"blockAndAggregate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Result[]\",\"name\":\"returnData\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBasefee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"basefee\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"name\":\"getBlockHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getChainId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"chainid\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCurrentBlockCoinbase\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"coinbase\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCurrentBlockDifficulty\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"difficulty\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCurrentBlockGasLimit\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"gaslimit\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCurrentBlockTimestamp\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"getEthBalance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastBlockHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"requireSuccess\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Call[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"tryAggregate\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Result[]\",\"name\":\"returnData\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"requireSuccess\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Call[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"tryBlockAndAggregate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Result[]\",\"name\":\"returnData\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"}]",
+}
+
+// IMulticall3ABI is the input ABI used to generate the binding from.
+// Deprecated: Use IMulticall3MetaData.ABI instead.
+var IMulticall3ABI = IMulticall3MetaData.ABI
+
+// IMulticall3 is an auto generated Go binding around an Ethereum contract.
+type IMulticall3 struct {
+	IMulticall3Caller     // Read-only binding to the contract
+	IMulticall3Transactor // Write-only binding to the contract
+	IMulticall3Filterer   // Log filterer for contract events
+}
+
+// IMulticall3Caller is an auto generated read-only Go binding around an Ethereum contract.
+type IMulticall3Caller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IMulticall3Transactor is an auto generated write-only Go binding around an Ethereum contract.
+type IMulticall3Transactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IMulticall3Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type IMulticall3Filterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IMulticall3Session is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type IMulticall3Session struct {
+	Contract     *IMulticall3      // 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
+}
+
+// IMulticall3CallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type IMulticall3CallerSession struct {
+	Contract *IMulticall3Caller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts      // Call options to use throughout this session
+}
+
+// IMulticall3TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type IMulticall3TransactorSession struct {
+	Contract     *IMulticall3Transactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts      // Transaction auth options to use throughout this session
+}
+
+// IMulticall3Raw is an auto generated low-level Go binding around an Ethereum contract.
+type IMulticall3Raw struct {
+	Contract *IMulticall3 // Generic contract binding to access the raw methods on
+}
+
+// IMulticall3CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type IMulticall3CallerRaw struct {
+	Contract *IMulticall3Caller // Generic read-only contract binding to access the raw methods on
+}
+
+// IMulticall3TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type IMulticall3TransactorRaw struct {
+	Contract *IMulticall3Transactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewIMulticall3 creates a new instance of IMulticall3, bound to a specific deployed contract.
+func NewIMulticall3(address common.Address, backend bind.ContractBackend) (*IMulticall3, error) {
+	contract, err := bindIMulticall3(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &IMulticall3{IMulticall3Caller: IMulticall3Caller{contract: contract}, IMulticall3Transactor: IMulticall3Transactor{contract: contract}, IMulticall3Filterer: IMulticall3Filterer{contract: contract}}, nil
+}
+
+// NewIMulticall3Caller creates a new read-only instance of IMulticall3, bound to a specific deployed contract.
+func NewIMulticall3Caller(address common.Address, caller bind.ContractCaller) (*IMulticall3Caller, error) {
+	contract, err := bindIMulticall3(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IMulticall3Caller{contract: contract}, nil
+}
+
+// NewIMulticall3Transactor creates a new write-only instance of IMulticall3, bound to a specific deployed contract.
+func NewIMulticall3Transactor(address common.Address, transactor bind.ContractTransactor) (*IMulticall3Transactor, error) {
+	contract, err := bindIMulticall3(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IMulticall3Transactor{contract: contract}, nil
+}
+
+// NewIMulticall3Filterer creates a new log filterer instance of IMulticall3, bound to a specific deployed contract.
+func NewIMulticall3Filterer(address common.Address, filterer bind.ContractFilterer) (*IMulticall3Filterer, error) {
+	contract, err := bindIMulticall3(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &IMulticall3Filterer{contract: contract}, nil
+}
+
+// bindIMulticall3 binds a generic wrapper to an already deployed contract.
+func bindIMulticall3(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := IMulticall3MetaData.GetAbi()
+	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 (_IMulticall3 *IMulticall3Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IMulticall3.Contract.IMulticall3Caller.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 (_IMulticall3 *IMulticall3Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IMulticall3.Contract.IMulticall3Transactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IMulticall3 *IMulticall3Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IMulticall3.Contract.IMulticall3Transactor.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 (_IMulticall3 *IMulticall3CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IMulticall3.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 (_IMulticall3 *IMulticall3TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IMulticall3.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IMulticall3 *IMulticall3TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IMulticall3.Contract.contract.Transact(opts, method, params...)
+}
+
+// GetBasefee is a free data retrieval call binding the contract method 0x3e64a696.
+//
+// Solidity: function getBasefee() view returns(uint256 basefee)
+func (_IMulticall3 *IMulticall3Caller) GetBasefee(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _IMulticall3.contract.Call(opts, &out, "getBasefee")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetBasefee is a free data retrieval call binding the contract method 0x3e64a696.
+//
+// Solidity: function getBasefee() view returns(uint256 basefee)
+func (_IMulticall3 *IMulticall3Session) GetBasefee() (*big.Int, error) {
+	return _IMulticall3.Contract.GetBasefee(&_IMulticall3.CallOpts)
+}
+
+// GetBasefee is a free data retrieval call binding the contract method 0x3e64a696.
+//
+// Solidity: function getBasefee() view returns(uint256 basefee)
+func (_IMulticall3 *IMulticall3CallerSession) GetBasefee() (*big.Int, error) {
+	return _IMulticall3.Contract.GetBasefee(&_IMulticall3.CallOpts)
+}
+
+// GetBlockHash is a free data retrieval call binding the contract method 0xee82ac5e.
+//
+// Solidity: function getBlockHash(uint256 blockNumber) view returns(bytes32 blockHash)
+func (_IMulticall3 *IMulticall3Caller) GetBlockHash(opts *bind.CallOpts, blockNumber *big.Int) ([32]byte, error) {
+	var out []interface{}
+	err := _IMulticall3.contract.Call(opts, &out, "getBlockHash", blockNumber)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// GetBlockHash is a free data retrieval call binding the contract method 0xee82ac5e.
+//
+// Solidity: function getBlockHash(uint256 blockNumber) view returns(bytes32 blockHash)
+func (_IMulticall3 *IMulticall3Session) GetBlockHash(blockNumber *big.Int) ([32]byte, error) {
+	return _IMulticall3.Contract.GetBlockHash(&_IMulticall3.CallOpts, blockNumber)
+}
+
+// GetBlockHash is a free data retrieval call binding the contract method 0xee82ac5e.
+//
+// Solidity: function getBlockHash(uint256 blockNumber) view returns(bytes32 blockHash)
+func (_IMulticall3 *IMulticall3CallerSession) GetBlockHash(blockNumber *big.Int) ([32]byte, error) {
+	return _IMulticall3.Contract.GetBlockHash(&_IMulticall3.CallOpts, blockNumber)
+}
+
+// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c.
+//
+// Solidity: function getBlockNumber() view returns(uint256 blockNumber)
+func (_IMulticall3 *IMulticall3Caller) GetBlockNumber(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _IMulticall3.contract.Call(opts, &out, "getBlockNumber")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c.
+//
+// Solidity: function getBlockNumber() view returns(uint256 blockNumber)
+func (_IMulticall3 *IMulticall3Session) GetBlockNumber() (*big.Int, error) {
+	return _IMulticall3.Contract.GetBlockNumber(&_IMulticall3.CallOpts)
+}
+
+// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c.
+//
+// Solidity: function getBlockNumber() view returns(uint256 blockNumber)
+func (_IMulticall3 *IMulticall3CallerSession) GetBlockNumber() (*big.Int, error) {
+	return _IMulticall3.Contract.GetBlockNumber(&_IMulticall3.CallOpts)
+}
+
+// GetChainId is a free data retrieval call binding the contract method 0x3408e470.
+//
+// Solidity: function getChainId() view returns(uint256 chainid)
+func (_IMulticall3 *IMulticall3Caller) GetChainId(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _IMulticall3.contract.Call(opts, &out, "getChainId")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetChainId is a free data retrieval call binding the contract method 0x3408e470.
+//
+// Solidity: function getChainId() view returns(uint256 chainid)
+func (_IMulticall3 *IMulticall3Session) GetChainId() (*big.Int, error) {
+	return _IMulticall3.Contract.GetChainId(&_IMulticall3.CallOpts)
+}
+
+// GetChainId is a free data retrieval call binding the contract method 0x3408e470.
+//
+// Solidity: function getChainId() view returns(uint256 chainid)
+func (_IMulticall3 *IMulticall3CallerSession) GetChainId() (*big.Int, error) {
+	return _IMulticall3.Contract.GetChainId(&_IMulticall3.CallOpts)
+}
+
+// GetCurrentBlockCoinbase is a free data retrieval call binding the contract method 0xa8b0574e.
+//
+// Solidity: function getCurrentBlockCoinbase() view returns(address coinbase)
+func (_IMulticall3 *IMulticall3Caller) GetCurrentBlockCoinbase(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _IMulticall3.contract.Call(opts, &out, "getCurrentBlockCoinbase")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// GetCurrentBlockCoinbase is a free data retrieval call binding the contract method 0xa8b0574e.
+//
+// Solidity: function getCurrentBlockCoinbase() view returns(address coinbase)
+func (_IMulticall3 *IMulticall3Session) GetCurrentBlockCoinbase() (common.Address, error) {
+	return _IMulticall3.Contract.GetCurrentBlockCoinbase(&_IMulticall3.CallOpts)
+}
+
+// GetCurrentBlockCoinbase is a free data retrieval call binding the contract method 0xa8b0574e.
+//
+// Solidity: function getCurrentBlockCoinbase() view returns(address coinbase)
+func (_IMulticall3 *IMulticall3CallerSession) GetCurrentBlockCoinbase() (common.Address, error) {
+	return _IMulticall3.Contract.GetCurrentBlockCoinbase(&_IMulticall3.CallOpts)
+}
+
+// GetCurrentBlockDifficulty is a free data retrieval call binding the contract method 0x72425d9d.
+//
+// Solidity: function getCurrentBlockDifficulty() view returns(uint256 difficulty)
+func (_IMulticall3 *IMulticall3Caller) GetCurrentBlockDifficulty(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _IMulticall3.contract.Call(opts, &out, "getCurrentBlockDifficulty")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetCurrentBlockDifficulty is a free data retrieval call binding the contract method 0x72425d9d.
+//
+// Solidity: function getCurrentBlockDifficulty() view returns(uint256 difficulty)
+func (_IMulticall3 *IMulticall3Session) GetCurrentBlockDifficulty() (*big.Int, error) {
+	return _IMulticall3.Contract.GetCurrentBlockDifficulty(&_IMulticall3.CallOpts)
+}
+
+// GetCurrentBlockDifficulty is a free data retrieval call binding the contract method 0x72425d9d.
+//
+// Solidity: function getCurrentBlockDifficulty() view returns(uint256 difficulty)
+func (_IMulticall3 *IMulticall3CallerSession) GetCurrentBlockDifficulty() (*big.Int, error) {
+	return _IMulticall3.Contract.GetCurrentBlockDifficulty(&_IMulticall3.CallOpts)
+}
+
+// GetCurrentBlockGasLimit is a free data retrieval call binding the contract method 0x86d516e8.
+//
+// Solidity: function getCurrentBlockGasLimit() view returns(uint256 gaslimit)
+func (_IMulticall3 *IMulticall3Caller) GetCurrentBlockGasLimit(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _IMulticall3.contract.Call(opts, &out, "getCurrentBlockGasLimit")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetCurrentBlockGasLimit is a free data retrieval call binding the contract method 0x86d516e8.
+//
+// Solidity: function getCurrentBlockGasLimit() view returns(uint256 gaslimit)
+func (_IMulticall3 *IMulticall3Session) GetCurrentBlockGasLimit() (*big.Int, error) {
+	return _IMulticall3.Contract.GetCurrentBlockGasLimit(&_IMulticall3.CallOpts)
+}
+
+// GetCurrentBlockGasLimit is a free data retrieval call binding the contract method 0x86d516e8.
+//
+// Solidity: function getCurrentBlockGasLimit() view returns(uint256 gaslimit)
+func (_IMulticall3 *IMulticall3CallerSession) GetCurrentBlockGasLimit() (*big.Int, error) {
+	return _IMulticall3.Contract.GetCurrentBlockGasLimit(&_IMulticall3.CallOpts)
+}
+
+// GetCurrentBlockTimestamp is a free data retrieval call binding the contract method 0x0f28c97d.
+//
+// Solidity: function getCurrentBlockTimestamp() view returns(uint256 timestamp)
+func (_IMulticall3 *IMulticall3Caller) GetCurrentBlockTimestamp(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _IMulticall3.contract.Call(opts, &out, "getCurrentBlockTimestamp")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetCurrentBlockTimestamp is a free data retrieval call binding the contract method 0x0f28c97d.
+//
+// Solidity: function getCurrentBlockTimestamp() view returns(uint256 timestamp)
+func (_IMulticall3 *IMulticall3Session) GetCurrentBlockTimestamp() (*big.Int, error) {
+	return _IMulticall3.Contract.GetCurrentBlockTimestamp(&_IMulticall3.CallOpts)
+}
+
+// GetCurrentBlockTimestamp is a free data retrieval call binding the contract method 0x0f28c97d.
+//
+// Solidity: function getCurrentBlockTimestamp() view returns(uint256 timestamp)
+func (_IMulticall3 *IMulticall3CallerSession) GetCurrentBlockTimestamp() (*big.Int, error) {
+	return _IMulticall3.Contract.GetCurrentBlockTimestamp(&_IMulticall3.CallOpts)
+}
+
+// GetEthBalance is a free data retrieval call binding the contract method 0x4d2301cc.
+//
+// Solidity: function getEthBalance(address addr) view returns(uint256 balance)
+func (_IMulticall3 *IMulticall3Caller) GetEthBalance(opts *bind.CallOpts, addr common.Address) (*big.Int, error) {
+	var out []interface{}
+	err := _IMulticall3.contract.Call(opts, &out, "getEthBalance", addr)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetEthBalance is a free data retrieval call binding the contract method 0x4d2301cc.
+//
+// Solidity: function getEthBalance(address addr) view returns(uint256 balance)
+func (_IMulticall3 *IMulticall3Session) GetEthBalance(addr common.Address) (*big.Int, error) {
+	return _IMulticall3.Contract.GetEthBalance(&_IMulticall3.CallOpts, addr)
+}
+
+// GetEthBalance is a free data retrieval call binding the contract method 0x4d2301cc.
+//
+// Solidity: function getEthBalance(address addr) view returns(uint256 balance)
+func (_IMulticall3 *IMulticall3CallerSession) GetEthBalance(addr common.Address) (*big.Int, error) {
+	return _IMulticall3.Contract.GetEthBalance(&_IMulticall3.CallOpts, addr)
+}
+
+// GetLastBlockHash is a free data retrieval call binding the contract method 0x27e86d6e.
+//
+// Solidity: function getLastBlockHash() view returns(bytes32 blockHash)
+func (_IMulticall3 *IMulticall3Caller) GetLastBlockHash(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _IMulticall3.contract.Call(opts, &out, "getLastBlockHash")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// GetLastBlockHash is a free data retrieval call binding the contract method 0x27e86d6e.
+//
+// Solidity: function getLastBlockHash() view returns(bytes32 blockHash)
+func (_IMulticall3 *IMulticall3Session) GetLastBlockHash() ([32]byte, error) {
+	return _IMulticall3.Contract.GetLastBlockHash(&_IMulticall3.CallOpts)
+}
+
+// GetLastBlockHash is a free data retrieval call binding the contract method 0x27e86d6e.
+//
+// Solidity: function getLastBlockHash() view returns(bytes32 blockHash)
+func (_IMulticall3 *IMulticall3CallerSession) GetLastBlockHash() ([32]byte, error) {
+	return _IMulticall3.Contract.GetLastBlockHash(&_IMulticall3.CallOpts)
+}
+
+// Aggregate is a paid mutator transaction binding the contract method 0x252dba42.
+//
+// Solidity: function aggregate((address,bytes)[] calls) payable returns(uint256 blockNumber, bytes[] returnData)
+func (_IMulticall3 *IMulticall3Transactor) Aggregate(opts *bind.TransactOpts, calls []IMulticall3Call) (*types.Transaction, error) {
+	return _IMulticall3.contract.Transact(opts, "aggregate", calls)
+}
+
+// Aggregate is a paid mutator transaction binding the contract method 0x252dba42.
+//
+// Solidity: function aggregate((address,bytes)[] calls) payable returns(uint256 blockNumber, bytes[] returnData)
+func (_IMulticall3 *IMulticall3Session) Aggregate(calls []IMulticall3Call) (*types.Transaction, error) {
+	return _IMulticall3.Contract.Aggregate(&_IMulticall3.TransactOpts, calls)
+}
+
+// Aggregate is a paid mutator transaction binding the contract method 0x252dba42.
+//
+// Solidity: function aggregate((address,bytes)[] calls) payable returns(uint256 blockNumber, bytes[] returnData)
+func (_IMulticall3 *IMulticall3TransactorSession) Aggregate(calls []IMulticall3Call) (*types.Transaction, error) {
+	return _IMulticall3.Contract.Aggregate(&_IMulticall3.TransactOpts, calls)
+}
+
+// Aggregate3 is a paid mutator transaction binding the contract method 0x82ad56cb.
+//
+// Solidity: function aggregate3((address,bool,bytes)[] calls) payable returns((bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3Transactor) Aggregate3(opts *bind.TransactOpts, calls []IMulticall3Call3) (*types.Transaction, error) {
+	return _IMulticall3.contract.Transact(opts, "aggregate3", calls)
+}
+
+// Aggregate3 is a paid mutator transaction binding the contract method 0x82ad56cb.
+//
+// Solidity: function aggregate3((address,bool,bytes)[] calls) payable returns((bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3Session) Aggregate3(calls []IMulticall3Call3) (*types.Transaction, error) {
+	return _IMulticall3.Contract.Aggregate3(&_IMulticall3.TransactOpts, calls)
+}
+
+// Aggregate3 is a paid mutator transaction binding the contract method 0x82ad56cb.
+//
+// Solidity: function aggregate3((address,bool,bytes)[] calls) payable returns((bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3TransactorSession) Aggregate3(calls []IMulticall3Call3) (*types.Transaction, error) {
+	return _IMulticall3.Contract.Aggregate3(&_IMulticall3.TransactOpts, calls)
+}
+
+// Aggregate3Value is a paid mutator transaction binding the contract method 0x174dea71.
+//
+// Solidity: function aggregate3Value((address,bool,uint256,bytes)[] calls) payable returns((bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3Transactor) Aggregate3Value(opts *bind.TransactOpts, calls []IMulticall3Call3Value) (*types.Transaction, error) {
+	return _IMulticall3.contract.Transact(opts, "aggregate3Value", calls)
+}
+
+// Aggregate3Value is a paid mutator transaction binding the contract method 0x174dea71.
+//
+// Solidity: function aggregate3Value((address,bool,uint256,bytes)[] calls) payable returns((bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3Session) Aggregate3Value(calls []IMulticall3Call3Value) (*types.Transaction, error) {
+	return _IMulticall3.Contract.Aggregate3Value(&_IMulticall3.TransactOpts, calls)
+}
+
+// Aggregate3Value is a paid mutator transaction binding the contract method 0x174dea71.
+//
+// Solidity: function aggregate3Value((address,bool,uint256,bytes)[] calls) payable returns((bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3TransactorSession) Aggregate3Value(calls []IMulticall3Call3Value) (*types.Transaction, error) {
+	return _IMulticall3.Contract.Aggregate3Value(&_IMulticall3.TransactOpts, calls)
+}
+
+// BlockAndAggregate is a paid mutator transaction binding the contract method 0xc3077fa9.
+//
+// Solidity: function blockAndAggregate((address,bytes)[] calls) payable returns(uint256 blockNumber, bytes32 blockHash, (bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3Transactor) BlockAndAggregate(opts *bind.TransactOpts, calls []IMulticall3Call) (*types.Transaction, error) {
+	return _IMulticall3.contract.Transact(opts, "blockAndAggregate", calls)
+}
+
+// BlockAndAggregate is a paid mutator transaction binding the contract method 0xc3077fa9.
+//
+// Solidity: function blockAndAggregate((address,bytes)[] calls) payable returns(uint256 blockNumber, bytes32 blockHash, (bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3Session) BlockAndAggregate(calls []IMulticall3Call) (*types.Transaction, error) {
+	return _IMulticall3.Contract.BlockAndAggregate(&_IMulticall3.TransactOpts, calls)
+}
+
+// BlockAndAggregate is a paid mutator transaction binding the contract method 0xc3077fa9.
+//
+// Solidity: function blockAndAggregate((address,bytes)[] calls) payable returns(uint256 blockNumber, bytes32 blockHash, (bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3TransactorSession) BlockAndAggregate(calls []IMulticall3Call) (*types.Transaction, error) {
+	return _IMulticall3.Contract.BlockAndAggregate(&_IMulticall3.TransactOpts, calls)
+}
+
+// TryAggregate is a paid mutator transaction binding the contract method 0xbce38bd7.
+//
+// Solidity: function tryAggregate(bool requireSuccess, (address,bytes)[] calls) payable returns((bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3Transactor) TryAggregate(opts *bind.TransactOpts, requireSuccess bool, calls []IMulticall3Call) (*types.Transaction, error) {
+	return _IMulticall3.contract.Transact(opts, "tryAggregate", requireSuccess, calls)
+}
+
+// TryAggregate is a paid mutator transaction binding the contract method 0xbce38bd7.
+//
+// Solidity: function tryAggregate(bool requireSuccess, (address,bytes)[] calls) payable returns((bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3Session) TryAggregate(requireSuccess bool, calls []IMulticall3Call) (*types.Transaction, error) {
+	return _IMulticall3.Contract.TryAggregate(&_IMulticall3.TransactOpts, requireSuccess, calls)
+}
+
+// TryAggregate is a paid mutator transaction binding the contract method 0xbce38bd7.
+//
+// Solidity: function tryAggregate(bool requireSuccess, (address,bytes)[] calls) payable returns((bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3TransactorSession) TryAggregate(requireSuccess bool, calls []IMulticall3Call) (*types.Transaction, error) {
+	return _IMulticall3.Contract.TryAggregate(&_IMulticall3.TransactOpts, requireSuccess, calls)
+}
+
+// TryBlockAndAggregate is a paid mutator transaction binding the contract method 0x399542e9.
+//
+// Solidity: function tryBlockAndAggregate(bool requireSuccess, (address,bytes)[] calls) payable returns(uint256 blockNumber, bytes32 blockHash, (bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3Transactor) TryBlockAndAggregate(opts *bind.TransactOpts, requireSuccess bool, calls []IMulticall3Call) (*types.Transaction, error) {
+	return _IMulticall3.contract.Transact(opts, "tryBlockAndAggregate", requireSuccess, calls)
+}
+
+// TryBlockAndAggregate is a paid mutator transaction binding the contract method 0x399542e9.
+//
+// Solidity: function tryBlockAndAggregate(bool requireSuccess, (address,bytes)[] calls) payable returns(uint256 blockNumber, bytes32 blockHash, (bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3Session) TryBlockAndAggregate(requireSuccess bool, calls []IMulticall3Call) (*types.Transaction, error) {
+	return _IMulticall3.Contract.TryBlockAndAggregate(&_IMulticall3.TransactOpts, requireSuccess, calls)
+}
+
+// TryBlockAndAggregate is a paid mutator transaction binding the contract method 0x399542e9.
+//
+// Solidity: function tryBlockAndAggregate(bool requireSuccess, (address,bytes)[] calls) payable returns(uint256 blockNumber, bytes32 blockHash, (bool,bytes)[] returnData)
+func (_IMulticall3 *IMulticall3TransactorSession) TryBlockAndAggregate(requireSuccess bool, calls []IMulticall3Call) (*types.Transaction, error) {
+	return _IMulticall3.Contract.TryBlockAndAggregate(&_IMulticall3.TransactOpts, requireSuccess, calls)
+}
+
+// IPCCSRouterMetaData contains all meta data concerning the IPCCSRouter contract.
+var IPCCSRouterMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"crlHelperAddr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"fmspcTcbDaoAddr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumCA\",\"name\":\"ca\",\"type\":\"uint8\"}],\"name\":\"getCert\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumCA\",\"name\":\"ca\",\"type\":\"uint8\"}],\"name\":\"getCertHash\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumCA\",\"name\":\"ca\",\"type\":\"uint8\"}],\"name\":\"getCrl\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumCA\",\"name\":\"ca\",\"type\":\"uint8\"}],\"name\":\"getCrlHash\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes6\",\"name\":\"fmspc\",\"type\":\"bytes6\"}],\"name\":\"getFmspcTcbV2\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"uint16\",\"name\":\"pcesvn\",\"type\":\"uint16\"},{\"internalType\":\"uint8[]\",\"name\":\"sgxComponentCpuSvns\",\"type\":\"uint8[]\"},{\"internalType\":\"uint8[]\",\"name\":\"tdxSvns\",\"type\":\"uint8[]\"},{\"internalType\":\"uint64\",\"name\":\"tcbDateTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"enumTCBStatus\",\"name\":\"status\",\"type\":\"uint8\"},{\"internalType\":\"string[]\",\"name\":\"advisoryIDs\",\"type\":\"string[]\"}],\"internalType\":\"structTCBLevelsObj[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumTcbId\",\"name\":\"id\",\"type\":\"uint8\"},{\"internalType\":\"bytes6\",\"name\":\"fmspc\",\"type\":\"bytes6\"}],\"name\":\"getFmspcTcbV3\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"uint16\",\"name\":\"pcesvn\",\"type\":\"uint16\"},{\"internalType\":\"uint8[]\",\"name\":\"sgxComponentCpuSvns\",\"type\":\"uint8[]\"},{\"internalType\":\"uint8[]\",\"name\":\"tdxSvns\",\"type\":\"uint8[]\"},{\"internalType\":\"uint64\",\"name\":\"tcbDateTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"enumTCBStatus\",\"name\":\"status\",\"type\":\"uint8\"},{\"internalType\":\"string[]\",\"name\":\"advisoryIDs\",\"type\":\"string[]\"}],\"internalType\":\"structTCBLevelsObj[]\",\"name\":\"\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"bytes\",\"name\":\"mrsigner\",\"type\":\"bytes\"},{\"internalType\":\"bytes8\",\"name\":\"attributes\",\"type\":\"bytes8\"},{\"internalType\":\"bytes8\",\"name\":\"attributesMask\",\"type\":\"bytes8\"}],\"internalType\":\"structTDXModule\",\"name\":\"\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"string\",\"name\":\"id\",\"type\":\"string\"},{\"internalType\":\"bytes8\",\"name\":\"attributes\",\"type\":\"bytes8\"},{\"internalType\":\"bytes8\",\"name\":\"attributesMask\",\"type\":\"bytes8\"},{\"internalType\":\"bytes\",\"name\":\"mrsigner\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"uint8\",\"name\":\"isvsvn\",\"type\":\"uint8\"},{\"internalType\":\"uint64\",\"name\":\"tcbDateTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"enumTCBStatus\",\"name\":\"status\",\"type\":\"uint8\"}],\"internalType\":\"structTDXModuleTCBLevelsObj[]\",\"name\":\"tcbLevels\",\"type\":\"tuple[]\"}],\"internalType\":\"structTDXModuleIdentity[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"qeid\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"platformCpuSvn\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"platformPceSvn\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"pceid\",\"type\":\"string\"}],\"name\":\"getPckCert\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumEnclaveId\",\"name\":\"id\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"quoteVersion\",\"type\":\"uint256\"}],\"name\":\"getQeIdentity\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"enumEnclaveId\",\"name\":\"id\",\"type\":\"uint8\"},{\"internalType\":\"uint32\",\"name\":\"version\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"issueDateTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"nextUpdateTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint32\",\"name\":\"tcbEvaluationDataNumber\",\"type\":\"uint32\"},{\"internalType\":\"bytes4\",\"name\":\"miscselect\",\"type\":\"bytes4\"},{\"internalType\":\"bytes4\",\"name\":\"miscselectMask\",\"type\":\"bytes4\"},{\"internalType\":\"bytes16\",\"name\":\"attributes\",\"type\":\"bytes16\"},{\"internalType\":\"bytes16\",\"name\":\"attributesMask\",\"type\":\"bytes16\"},{\"internalType\":\"bytes32\",\"name\":\"mrsigner\",\"type\":\"bytes32\"},{\"internalType\":\"uint16\",\"name\":\"isvprodid\",\"type\":\"uint16\"},{\"components\":[{\"internalType\":\"uint16\",\"name\":\"isvsvn\",\"type\":\"uint16\"},{\"internalType\":\"uint256\",\"name\":\"dateTimestamp\",\"type\":\"uint256\"},{\"internalType\":\"enumEnclaveIdTcbStatus\",\"name\":\"status\",\"type\":\"uint8\"}],\"internalType\":\"structTcb[]\",\"name\":\"tcb\",\"type\":\"tuple[]\"}],\"internalType\":\"structIdentityObj\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pckDaoAddr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pckHelperAddr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pcsDaoAddr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"qeIdDaoAddr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+}
+
+// IPCCSRouterABI is the input ABI used to generate the binding from.
+// Deprecated: Use IPCCSRouterMetaData.ABI instead.
+var IPCCSRouterABI = IPCCSRouterMetaData.ABI
+
+// IPCCSRouter is an auto generated Go binding around an Ethereum contract.
+type IPCCSRouter struct {
+	IPCCSRouterCaller     // Read-only binding to the contract
+	IPCCSRouterTransactor // Write-only binding to the contract
+	IPCCSRouterFilterer   // Log filterer for contract events
+}
+
+// IPCCSRouterCaller is an auto generated read-only Go binding around an Ethereum contract.
+type IPCCSRouterCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IPCCSRouterTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type IPCCSRouterTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IPCCSRouterFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type IPCCSRouterFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IPCCSRouterSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type IPCCSRouterSession struct {
+	Contract     *IPCCSRouter      // 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
+}
+
+// IPCCSRouterCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type IPCCSRouterCallerSession struct {
+	Contract *IPCCSRouterCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts      // Call options to use throughout this session
+}
+
+// IPCCSRouterTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type IPCCSRouterTransactorSession struct {
+	Contract     *IPCCSRouterTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts      // Transaction auth options to use throughout this session
+}
+
+// IPCCSRouterRaw is an auto generated low-level Go binding around an Ethereum contract.
+type IPCCSRouterRaw struct {
+	Contract *IPCCSRouter // Generic contract binding to access the raw methods on
+}
+
+// IPCCSRouterCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type IPCCSRouterCallerRaw struct {
+	Contract *IPCCSRouterCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// IPCCSRouterTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type IPCCSRouterTransactorRaw struct {
+	Contract *IPCCSRouterTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewIPCCSRouter creates a new instance of IPCCSRouter, bound to a specific deployed contract.
+func NewIPCCSRouter(address common.Address, backend bind.ContractBackend) (*IPCCSRouter, error) {
+	contract, err := bindIPCCSRouter(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &IPCCSRouter{IPCCSRouterCaller: IPCCSRouterCaller{contract: contract}, IPCCSRouterTransactor: IPCCSRouterTransactor{contract: contract}, IPCCSRouterFilterer: IPCCSRouterFilterer{contract: contract}}, nil
+}
+
+// NewIPCCSRouterCaller creates a new read-only instance of IPCCSRouter, bound to a specific deployed contract.
+func NewIPCCSRouterCaller(address common.Address, caller bind.ContractCaller) (*IPCCSRouterCaller, error) {
+	contract, err := bindIPCCSRouter(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IPCCSRouterCaller{contract: contract}, nil
+}
+
+// NewIPCCSRouterTransactor creates a new write-only instance of IPCCSRouter, bound to a specific deployed contract.
+func NewIPCCSRouterTransactor(address common.Address, transactor bind.ContractTransactor) (*IPCCSRouterTransactor, error) {
+	contract, err := bindIPCCSRouter(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IPCCSRouterTransactor{contract: contract}, nil
+}
+
+// NewIPCCSRouterFilterer creates a new log filterer instance of IPCCSRouter, bound to a specific deployed contract.
+func NewIPCCSRouterFilterer(address common.Address, filterer bind.ContractFilterer) (*IPCCSRouterFilterer, error) {
+	contract, err := bindIPCCSRouter(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &IPCCSRouterFilterer{contract: contract}, nil
+}
+
+// bindIPCCSRouter binds a generic wrapper to an already deployed contract.
+func bindIPCCSRouter(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := IPCCSRouterMetaData.GetAbi()
+	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 (_IPCCSRouter *IPCCSRouterRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IPCCSRouter.Contract.IPCCSRouterCaller.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 (_IPCCSRouter *IPCCSRouterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IPCCSRouter.Contract.IPCCSRouterTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IPCCSRouter *IPCCSRouterRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IPCCSRouter.Contract.IPCCSRouterTransactor.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 (_IPCCSRouter *IPCCSRouterCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IPCCSRouter.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 (_IPCCSRouter *IPCCSRouterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IPCCSRouter.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IPCCSRouter *IPCCSRouterTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IPCCSRouter.Contract.contract.Transact(opts, method, params...)
+}
+
+// CrlHelperAddr is a free data retrieval call binding the contract method 0x3fcb603b.
+//
+// Solidity: function crlHelperAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterCaller) CrlHelperAddr(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "crlHelperAddr")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// CrlHelperAddr is a free data retrieval call binding the contract method 0x3fcb603b.
+//
+// Solidity: function crlHelperAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterSession) CrlHelperAddr() (common.Address, error) {
+	return _IPCCSRouter.Contract.CrlHelperAddr(&_IPCCSRouter.CallOpts)
+}
+
+// CrlHelperAddr is a free data retrieval call binding the contract method 0x3fcb603b.
+//
+// Solidity: function crlHelperAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterCallerSession) CrlHelperAddr() (common.Address, error) {
+	return _IPCCSRouter.Contract.CrlHelperAddr(&_IPCCSRouter.CallOpts)
+}
+
+// FmspcTcbDaoAddr is a free data retrieval call binding the contract method 0x4a27215b.
+//
+// Solidity: function fmspcTcbDaoAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterCaller) FmspcTcbDaoAddr(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "fmspcTcbDaoAddr")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// FmspcTcbDaoAddr is a free data retrieval call binding the contract method 0x4a27215b.
+//
+// Solidity: function fmspcTcbDaoAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterSession) FmspcTcbDaoAddr() (common.Address, error) {
+	return _IPCCSRouter.Contract.FmspcTcbDaoAddr(&_IPCCSRouter.CallOpts)
+}
+
+// FmspcTcbDaoAddr is a free data retrieval call binding the contract method 0x4a27215b.
+//
+// Solidity: function fmspcTcbDaoAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterCallerSession) FmspcTcbDaoAddr() (common.Address, error) {
+	return _IPCCSRouter.Contract.FmspcTcbDaoAddr(&_IPCCSRouter.CallOpts)
+}
+
+// GetCert is a free data retrieval call binding the contract method 0xccbfa648.
+//
+// Solidity: function getCert(uint8 ca) view returns(bool, bytes)
+func (_IPCCSRouter *IPCCSRouterCaller) GetCert(opts *bind.CallOpts, ca uint8) (bool, []byte, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "getCert", ca)
+
+	if err != nil {
+		return *new(bool), *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+	out1 := *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return out0, out1, err
+
+}
+
+// GetCert is a free data retrieval call binding the contract method 0xccbfa648.
+//
+// Solidity: function getCert(uint8 ca) view returns(bool, bytes)
+func (_IPCCSRouter *IPCCSRouterSession) GetCert(ca uint8) (bool, []byte, error) {
+	return _IPCCSRouter.Contract.GetCert(&_IPCCSRouter.CallOpts, ca)
+}
+
+// GetCert is a free data retrieval call binding the contract method 0xccbfa648.
+//
+// Solidity: function getCert(uint8 ca) view returns(bool, bytes)
+func (_IPCCSRouter *IPCCSRouterCallerSession) GetCert(ca uint8) (bool, []byte, error) {
+	return _IPCCSRouter.Contract.GetCert(&_IPCCSRouter.CallOpts, ca)
+}
+
+// GetCertHash is a free data retrieval call binding the contract method 0x943374c9.
+//
+// Solidity: function getCertHash(uint8 ca) view returns(bool, bytes32)
+func (_IPCCSRouter *IPCCSRouterCaller) GetCertHash(opts *bind.CallOpts, ca uint8) (bool, [32]byte, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "getCertHash", ca)
+
+	if err != nil {
+		return *new(bool), *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+	out1 := *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+
+	return out0, out1, err
+
+}
+
+// GetCertHash is a free data retrieval call binding the contract method 0x943374c9.
+//
+// Solidity: function getCertHash(uint8 ca) view returns(bool, bytes32)
+func (_IPCCSRouter *IPCCSRouterSession) GetCertHash(ca uint8) (bool, [32]byte, error) {
+	return _IPCCSRouter.Contract.GetCertHash(&_IPCCSRouter.CallOpts, ca)
+}
+
+// GetCertHash is a free data retrieval call binding the contract method 0x943374c9.
+//
+// Solidity: function getCertHash(uint8 ca) view returns(bool, bytes32)
+func (_IPCCSRouter *IPCCSRouterCallerSession) GetCertHash(ca uint8) (bool, [32]byte, error) {
+	return _IPCCSRouter.Contract.GetCertHash(&_IPCCSRouter.CallOpts, ca)
+}
+
+// GetCrl is a free data retrieval call binding the contract method 0x1a60341c.
+//
+// Solidity: function getCrl(uint8 ca) view returns(bool, bytes)
+func (_IPCCSRouter *IPCCSRouterCaller) GetCrl(opts *bind.CallOpts, ca uint8) (bool, []byte, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "getCrl", ca)
+
+	if err != nil {
+		return *new(bool), *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+	out1 := *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return out0, out1, err
+
+}
+
+// GetCrl is a free data retrieval call binding the contract method 0x1a60341c.
+//
+// Solidity: function getCrl(uint8 ca) view returns(bool, bytes)
+func (_IPCCSRouter *IPCCSRouterSession) GetCrl(ca uint8) (bool, []byte, error) {
+	return _IPCCSRouter.Contract.GetCrl(&_IPCCSRouter.CallOpts, ca)
+}
+
+// GetCrl is a free data retrieval call binding the contract method 0x1a60341c.
+//
+// Solidity: function getCrl(uint8 ca) view returns(bool, bytes)
+func (_IPCCSRouter *IPCCSRouterCallerSession) GetCrl(ca uint8) (bool, []byte, error) {
+	return _IPCCSRouter.Contract.GetCrl(&_IPCCSRouter.CallOpts, ca)
+}
+
+// GetCrlHash is a free data retrieval call binding the contract method 0xc64c7b90.
+//
+// Solidity: function getCrlHash(uint8 ca) view returns(bool, bytes32)
+func (_IPCCSRouter *IPCCSRouterCaller) GetCrlHash(opts *bind.CallOpts, ca uint8) (bool, [32]byte, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "getCrlHash", ca)
+
+	if err != nil {
+		return *new(bool), *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+	out1 := *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+
+	return out0, out1, err
+
+}
+
+// GetCrlHash is a free data retrieval call binding the contract method 0xc64c7b90.
+//
+// Solidity: function getCrlHash(uint8 ca) view returns(bool, bytes32)
+func (_IPCCSRouter *IPCCSRouterSession) GetCrlHash(ca uint8) (bool, [32]byte, error) {
+	return _IPCCSRouter.Contract.GetCrlHash(&_IPCCSRouter.CallOpts, ca)
+}
+
+// GetCrlHash is a free data retrieval call binding the contract method 0xc64c7b90.
+//
+// Solidity: function getCrlHash(uint8 ca) view returns(bool, bytes32)
+func (_IPCCSRouter *IPCCSRouterCallerSession) GetCrlHash(ca uint8) (bool, [32]byte, error) {
+	return _IPCCSRouter.Contract.GetCrlHash(&_IPCCSRouter.CallOpts, ca)
+}
+
+// GetFmspcTcbV2 is a free data retrieval call binding the contract method 0xa498226f.
+//
+// Solidity: function getFmspcTcbV2(bytes6 fmspc) view returns(bool, (uint16,uint8[],uint8[],uint64,uint8,string[])[])
+func (_IPCCSRouter *IPCCSRouterCaller) GetFmspcTcbV2(opts *bind.CallOpts, fmspc [6]byte) (bool, []TCBLevelsObj, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "getFmspcTcbV2", fmspc)
+
+	if err != nil {
+		return *new(bool), *new([]TCBLevelsObj), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+	out1 := *abi.ConvertType(out[1], new([]TCBLevelsObj)).(*[]TCBLevelsObj)
+
+	return out0, out1, err
+
+}
+
+// GetFmspcTcbV2 is a free data retrieval call binding the contract method 0xa498226f.
+//
+// Solidity: function getFmspcTcbV2(bytes6 fmspc) view returns(bool, (uint16,uint8[],uint8[],uint64,uint8,string[])[])
+func (_IPCCSRouter *IPCCSRouterSession) GetFmspcTcbV2(fmspc [6]byte) (bool, []TCBLevelsObj, error) {
+	return _IPCCSRouter.Contract.GetFmspcTcbV2(&_IPCCSRouter.CallOpts, fmspc)
+}
+
+// GetFmspcTcbV2 is a free data retrieval call binding the contract method 0xa498226f.
+//
+// Solidity: function getFmspcTcbV2(bytes6 fmspc) view returns(bool, (uint16,uint8[],uint8[],uint64,uint8,string[])[])
+func (_IPCCSRouter *IPCCSRouterCallerSession) GetFmspcTcbV2(fmspc [6]byte) (bool, []TCBLevelsObj, error) {
+	return _IPCCSRouter.Contract.GetFmspcTcbV2(&_IPCCSRouter.CallOpts, fmspc)
+}
+
+// GetFmspcTcbV3 is a free data retrieval call binding the contract method 0xe69f6383.
+//
+// Solidity: function getFmspcTcbV3(uint8 id, bytes6 fmspc) view returns(bool, (uint16,uint8[],uint8[],uint64,uint8,string[])[], (bytes,bytes8,bytes8), (string,bytes8,bytes8,bytes,(uint8,uint64,uint8)[])[])
+func (_IPCCSRouter *IPCCSRouterCaller) GetFmspcTcbV3(opts *bind.CallOpts, id uint8, fmspc [6]byte) (bool, []TCBLevelsObj, TDXModule, []TDXModuleIdentity, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "getFmspcTcbV3", id, fmspc)
+
+	if err != nil {
+		return *new(bool), *new([]TCBLevelsObj), *new(TDXModule), *new([]TDXModuleIdentity), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+	out1 := *abi.ConvertType(out[1], new([]TCBLevelsObj)).(*[]TCBLevelsObj)
+	out2 := *abi.ConvertType(out[2], new(TDXModule)).(*TDXModule)
+	out3 := *abi.ConvertType(out[3], new([]TDXModuleIdentity)).(*[]TDXModuleIdentity)
+
+	return out0, out1, out2, out3, err
+
+}
+
+// GetFmspcTcbV3 is a free data retrieval call binding the contract method 0xe69f6383.
+//
+// Solidity: function getFmspcTcbV3(uint8 id, bytes6 fmspc) view returns(bool, (uint16,uint8[],uint8[],uint64,uint8,string[])[], (bytes,bytes8,bytes8), (string,bytes8,bytes8,bytes,(uint8,uint64,uint8)[])[])
+func (_IPCCSRouter *IPCCSRouterSession) GetFmspcTcbV3(id uint8, fmspc [6]byte) (bool, []TCBLevelsObj, TDXModule, []TDXModuleIdentity, error) {
+	return _IPCCSRouter.Contract.GetFmspcTcbV3(&_IPCCSRouter.CallOpts, id, fmspc)
+}
+
+// GetFmspcTcbV3 is a free data retrieval call binding the contract method 0xe69f6383.
+//
+// Solidity: function getFmspcTcbV3(uint8 id, bytes6 fmspc) view returns(bool, (uint16,uint8[],uint8[],uint64,uint8,string[])[], (bytes,bytes8,bytes8), (string,bytes8,bytes8,bytes,(uint8,uint64,uint8)[])[])
+func (_IPCCSRouter *IPCCSRouterCallerSession) GetFmspcTcbV3(id uint8, fmspc [6]byte) (bool, []TCBLevelsObj, TDXModule, []TDXModuleIdentity, error) {
+	return _IPCCSRouter.Contract.GetFmspcTcbV3(&_IPCCSRouter.CallOpts, id, fmspc)
+}
+
+// GetPckCert is a free data retrieval call binding the contract method 0x98e98ffe.
+//
+// Solidity: function getPckCert(string qeid, string platformCpuSvn, string platformPceSvn, string pceid) view returns(bool, bytes)
+func (_IPCCSRouter *IPCCSRouterCaller) GetPckCert(opts *bind.CallOpts, qeid string, platformCpuSvn string, platformPceSvn string, pceid string) (bool, []byte, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "getPckCert", qeid, platformCpuSvn, platformPceSvn, pceid)
+
+	if err != nil {
+		return *new(bool), *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+	out1 := *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return out0, out1, err
+
+}
+
+// GetPckCert is a free data retrieval call binding the contract method 0x98e98ffe.
+//
+// Solidity: function getPckCert(string qeid, string platformCpuSvn, string platformPceSvn, string pceid) view returns(bool, bytes)
+func (_IPCCSRouter *IPCCSRouterSession) GetPckCert(qeid string, platformCpuSvn string, platformPceSvn string, pceid string) (bool, []byte, error) {
+	return _IPCCSRouter.Contract.GetPckCert(&_IPCCSRouter.CallOpts, qeid, platformCpuSvn, platformPceSvn, pceid)
+}
+
+// GetPckCert is a free data retrieval call binding the contract method 0x98e98ffe.
+//
+// Solidity: function getPckCert(string qeid, string platformCpuSvn, string platformPceSvn, string pceid) view returns(bool, bytes)
+func (_IPCCSRouter *IPCCSRouterCallerSession) GetPckCert(qeid string, platformCpuSvn string, platformPceSvn string, pceid string) (bool, []byte, error) {
+	return _IPCCSRouter.Contract.GetPckCert(&_IPCCSRouter.CallOpts, qeid, platformCpuSvn, platformPceSvn, pceid)
+}
+
+// GetQeIdentity is a free data retrieval call binding the contract method 0xb9f1b94f.
+//
+// Solidity: function getQeIdentity(uint8 id, uint256 quoteVersion) view returns(bool, (uint8,uint32,uint64,uint64,uint32,bytes4,bytes4,bytes16,bytes16,bytes32,uint16,(uint16,uint256,uint8)[]))
+func (_IPCCSRouter *IPCCSRouterCaller) GetQeIdentity(opts *bind.CallOpts, id uint8, quoteVersion *big.Int) (bool, IdentityObj, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "getQeIdentity", id, quoteVersion)
+
+	if err != nil {
+		return *new(bool), *new(IdentityObj), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+	out1 := *abi.ConvertType(out[1], new(IdentityObj)).(*IdentityObj)
+
+	return out0, out1, err
+
+}
+
+// GetQeIdentity is a free data retrieval call binding the contract method 0xb9f1b94f.
+//
+// Solidity: function getQeIdentity(uint8 id, uint256 quoteVersion) view returns(bool, (uint8,uint32,uint64,uint64,uint32,bytes4,bytes4,bytes16,bytes16,bytes32,uint16,(uint16,uint256,uint8)[]))
+func (_IPCCSRouter *IPCCSRouterSession) GetQeIdentity(id uint8, quoteVersion *big.Int) (bool, IdentityObj, error) {
+	return _IPCCSRouter.Contract.GetQeIdentity(&_IPCCSRouter.CallOpts, id, quoteVersion)
+}
+
+// GetQeIdentity is a free data retrieval call binding the contract method 0xb9f1b94f.
+//
+// Solidity: function getQeIdentity(uint8 id, uint256 quoteVersion) view returns(bool, (uint8,uint32,uint64,uint64,uint32,bytes4,bytes4,bytes16,bytes16,bytes32,uint16,(uint16,uint256,uint8)[]))
+func (_IPCCSRouter *IPCCSRouterCallerSession) GetQeIdentity(id uint8, quoteVersion *big.Int) (bool, IdentityObj, error) {
+	return _IPCCSRouter.Contract.GetQeIdentity(&_IPCCSRouter.CallOpts, id, quoteVersion)
+}
+
+// PckDaoAddr is a free data retrieval call binding the contract method 0xd137d4a3.
+//
+// Solidity: function pckDaoAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterCaller) PckDaoAddr(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "pckDaoAddr")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// PckDaoAddr is a free data retrieval call binding the contract method 0xd137d4a3.
+//
+// Solidity: function pckDaoAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterSession) PckDaoAddr() (common.Address, error) {
+	return _IPCCSRouter.Contract.PckDaoAddr(&_IPCCSRouter.CallOpts)
+}
+
+// PckDaoAddr is a free data retrieval call binding the contract method 0xd137d4a3.
+//
+// Solidity: function pckDaoAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterCallerSession) PckDaoAddr() (common.Address, error) {
+	return _IPCCSRouter.Contract.PckDaoAddr(&_IPCCSRouter.CallOpts)
+}
+
+// PckHelperAddr is a free data retrieval call binding the contract method 0xe99bba53.
+//
+// Solidity: function pckHelperAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterCaller) PckHelperAddr(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "pckHelperAddr")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// PckHelperAddr is a free data retrieval call binding the contract method 0xe99bba53.
+//
+// Solidity: function pckHelperAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterSession) PckHelperAddr() (common.Address, error) {
+	return _IPCCSRouter.Contract.PckHelperAddr(&_IPCCSRouter.CallOpts)
+}
+
+// PckHelperAddr is a free data retrieval call binding the contract method 0xe99bba53.
+//
+// Solidity: function pckHelperAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterCallerSession) PckHelperAddr() (common.Address, error) {
+	return _IPCCSRouter.Contract.PckHelperAddr(&_IPCCSRouter.CallOpts)
+}
+
+// PcsDaoAddr is a free data retrieval call binding the contract method 0x67ecb139.
+//
+// Solidity: function pcsDaoAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterCaller) PcsDaoAddr(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "pcsDaoAddr")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// PcsDaoAddr is a free data retrieval call binding the contract method 0x67ecb139.
+//
+// Solidity: function pcsDaoAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterSession) PcsDaoAddr() (common.Address, error) {
+	return _IPCCSRouter.Contract.PcsDaoAddr(&_IPCCSRouter.CallOpts)
+}
+
+// PcsDaoAddr is a free data retrieval call binding the contract method 0x67ecb139.
+//
+// Solidity: function pcsDaoAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterCallerSession) PcsDaoAddr() (common.Address, error) {
+	return _IPCCSRouter.Contract.PcsDaoAddr(&_IPCCSRouter.CallOpts)
+}
+
+// QeIdDaoAddr is a free data retrieval call binding the contract method 0x01627c15.
+//
+// Solidity: function qeIdDaoAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterCaller) QeIdDaoAddr(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _IPCCSRouter.contract.Call(opts, &out, "qeIdDaoAddr")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// QeIdDaoAddr is a free data retrieval call binding the contract method 0x01627c15.
+//
+// Solidity: function qeIdDaoAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterSession) QeIdDaoAddr() (common.Address, error) {
+	return _IPCCSRouter.Contract.QeIdDaoAddr(&_IPCCSRouter.CallOpts)
+}
+
+// QeIdDaoAddr is a free data retrieval call binding the contract method 0x01627c15.
+//
+// Solidity: function qeIdDaoAddr() view returns(address)
+func (_IPCCSRouter *IPCCSRouterCallerSession) QeIdDaoAddr() (common.Address, error) {
+	return _IPCCSRouter.Contract.QeIdDaoAddr(&_IPCCSRouter.CallOpts)
+}
+
+// IQuoteVerifierMetaData contains all meta data concerning the IQuoteVerifier contract.
+var IQuoteVerifierMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"pccsRouter\",\"outputs\":[{\"internalType\":\"contractIPCCSRouter\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"quoteVersion\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint16\",\"name\":\"version\",\"type\":\"uint16\"},{\"internalType\":\"bytes2\",\"name\":\"attestationKeyType\",\"type\":\"bytes2\"},{\"internalType\":\"bytes4\",\"name\":\"teeType\",\"type\":\"bytes4\"},{\"internalType\":\"bytes2\",\"name\":\"qeSvn\",\"type\":\"bytes2\"},{\"internalType\":\"bytes2\",\"name\":\"pceSvn\",\"type\":\"bytes2\"},{\"internalType\":\"bytes16\",\"name\":\"qeVendorId\",\"type\":\"bytes16\"},{\"internalType\":\"bytes20\",\"name\":\"userData\",\"type\":\"bytes20\"}],\"internalType\":\"structHeader\",\"name\":\"\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"verifyQuote\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"verifyZkOutput\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+}
+
+// IQuoteVerifierABI is the input ABI used to generate the binding from.
+// Deprecated: Use IQuoteVerifierMetaData.ABI instead.
+var IQuoteVerifierABI = IQuoteVerifierMetaData.ABI
+
+// IQuoteVerifier is an auto generated Go binding around an Ethereum contract.
+type IQuoteVerifier struct {
+	IQuoteVerifierCaller     // Read-only binding to the contract
+	IQuoteVerifierTransactor // Write-only binding to the contract
+	IQuoteVerifierFilterer   // Log filterer for contract events
+}
+
+// IQuoteVerifierCaller is an auto generated read-only Go binding around an Ethereum contract.
+type IQuoteVerifierCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IQuoteVerifierTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type IQuoteVerifierTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IQuoteVerifierFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type IQuoteVerifierFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IQuoteVerifierSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type IQuoteVerifierSession struct {
+	Contract     *IQuoteVerifier   // 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
+}
+
+// IQuoteVerifierCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type IQuoteVerifierCallerSession struct {
+	Contract *IQuoteVerifierCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts         // Call options to use throughout this session
+}
+
+// IQuoteVerifierTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type IQuoteVerifierTransactorSession struct {
+	Contract     *IQuoteVerifierTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
+}
+
+// IQuoteVerifierRaw is an auto generated low-level Go binding around an Ethereum contract.
+type IQuoteVerifierRaw struct {
+	Contract *IQuoteVerifier // Generic contract binding to access the raw methods on
+}
+
+// IQuoteVerifierCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type IQuoteVerifierCallerRaw struct {
+	Contract *IQuoteVerifierCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// IQuoteVerifierTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type IQuoteVerifierTransactorRaw struct {
+	Contract *IQuoteVerifierTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewIQuoteVerifier creates a new instance of IQuoteVerifier, bound to a specific deployed contract.
+func NewIQuoteVerifier(address common.Address, backend bind.ContractBackend) (*IQuoteVerifier, error) {
+	contract, err := bindIQuoteVerifier(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &IQuoteVerifier{IQuoteVerifierCaller: IQuoteVerifierCaller{contract: contract}, IQuoteVerifierTransactor: IQuoteVerifierTransactor{contract: contract}, IQuoteVerifierFilterer: IQuoteVerifierFilterer{contract: contract}}, nil
+}
+
+// NewIQuoteVerifierCaller creates a new read-only instance of IQuoteVerifier, bound to a specific deployed contract.
+func NewIQuoteVerifierCaller(address common.Address, caller bind.ContractCaller) (*IQuoteVerifierCaller, error) {
+	contract, err := bindIQuoteVerifier(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IQuoteVerifierCaller{contract: contract}, nil
+}
+
+// NewIQuoteVerifierTransactor creates a new write-only instance of IQuoteVerifier, bound to a specific deployed contract.
+func NewIQuoteVerifierTransactor(address common.Address, transactor bind.ContractTransactor) (*IQuoteVerifierTransactor, error) {
+	contract, err := bindIQuoteVerifier(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IQuoteVerifierTransactor{contract: contract}, nil
+}
+
+// NewIQuoteVerifierFilterer creates a new log filterer instance of IQuoteVerifier, bound to a specific deployed contract.
+func NewIQuoteVerifierFilterer(address common.Address, filterer bind.ContractFilterer) (*IQuoteVerifierFilterer, error) {
+	contract, err := bindIQuoteVerifier(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &IQuoteVerifierFilterer{contract: contract}, nil
+}
+
+// bindIQuoteVerifier binds a generic wrapper to an already deployed contract.
+func bindIQuoteVerifier(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := IQuoteVerifierMetaData.GetAbi()
+	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 (_IQuoteVerifier *IQuoteVerifierRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IQuoteVerifier.Contract.IQuoteVerifierCaller.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 (_IQuoteVerifier *IQuoteVerifierRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IQuoteVerifier.Contract.IQuoteVerifierTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IQuoteVerifier *IQuoteVerifierRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IQuoteVerifier.Contract.IQuoteVerifierTransactor.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 (_IQuoteVerifier *IQuoteVerifierCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IQuoteVerifier.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 (_IQuoteVerifier *IQuoteVerifierTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IQuoteVerifier.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IQuoteVerifier *IQuoteVerifierTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IQuoteVerifier.Contract.contract.Transact(opts, method, params...)
+}
+
+// PccsRouter is a free data retrieval call binding the contract method 0x9e0fb0bf.
+//
+// Solidity: function pccsRouter() view returns(address)
+func (_IQuoteVerifier *IQuoteVerifierCaller) PccsRouter(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _IQuoteVerifier.contract.Call(opts, &out, "pccsRouter")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// PccsRouter is a free data retrieval call binding the contract method 0x9e0fb0bf.
+//
+// Solidity: function pccsRouter() view returns(address)
+func (_IQuoteVerifier *IQuoteVerifierSession) PccsRouter() (common.Address, error) {
+	return _IQuoteVerifier.Contract.PccsRouter(&_IQuoteVerifier.CallOpts)
+}
+
+// PccsRouter is a free data retrieval call binding the contract method 0x9e0fb0bf.
+//
+// Solidity: function pccsRouter() view returns(address)
+func (_IQuoteVerifier *IQuoteVerifierCallerSession) PccsRouter() (common.Address, error) {
+	return _IQuoteVerifier.Contract.PccsRouter(&_IQuoteVerifier.CallOpts)
+}
+
+// QuoteVersion is a free data retrieval call binding the contract method 0x02077837.
+//
+// Solidity: function quoteVersion() view returns(uint16)
+func (_IQuoteVerifier *IQuoteVerifierCaller) QuoteVersion(opts *bind.CallOpts) (uint16, error) {
+	var out []interface{}
+	err := _IQuoteVerifier.contract.Call(opts, &out, "quoteVersion")
+
+	if err != nil {
+		return *new(uint16), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint16)).(*uint16)
+
+	return out0, err
+
+}
+
+// QuoteVersion is a free data retrieval call binding the contract method 0x02077837.
+//
+// Solidity: function quoteVersion() view returns(uint16)
+func (_IQuoteVerifier *IQuoteVerifierSession) QuoteVersion() (uint16, error) {
+	return _IQuoteVerifier.Contract.QuoteVersion(&_IQuoteVerifier.CallOpts)
+}
+
+// QuoteVersion is a free data retrieval call binding the contract method 0x02077837.
+//
+// Solidity: function quoteVersion() view returns(uint16)
+func (_IQuoteVerifier *IQuoteVerifierCallerSession) QuoteVersion() (uint16, error) {
+	return _IQuoteVerifier.Contract.QuoteVersion(&_IQuoteVerifier.CallOpts)
+}
+
+// VerifyQuote is a free data retrieval call binding the contract method 0xf1495114.
+//
+// Solidity: function verifyQuote((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) , bytes ) view returns(bool, bytes)
+func (_IQuoteVerifier *IQuoteVerifierCaller) VerifyQuote(opts *bind.CallOpts, arg0 Header, arg1 []byte) (bool, []byte, error) {
+	var out []interface{}
+	err := _IQuoteVerifier.contract.Call(opts, &out, "verifyQuote", arg0, arg1)
+
+	if err != nil {
+		return *new(bool), *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+	out1 := *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return out0, out1, err
+
+}
+
+// VerifyQuote is a free data retrieval call binding the contract method 0xf1495114.
+//
+// Solidity: function verifyQuote((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) , bytes ) view returns(bool, bytes)
+func (_IQuoteVerifier *IQuoteVerifierSession) VerifyQuote(arg0 Header, arg1 []byte) (bool, []byte, error) {
+	return _IQuoteVerifier.Contract.VerifyQuote(&_IQuoteVerifier.CallOpts, arg0, arg1)
+}
+
+// VerifyQuote is a free data retrieval call binding the contract method 0xf1495114.
+//
+// Solidity: function verifyQuote((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) , bytes ) view returns(bool, bytes)
+func (_IQuoteVerifier *IQuoteVerifierCallerSession) VerifyQuote(arg0 Header, arg1 []byte) (bool, []byte, error) {
+	return _IQuoteVerifier.Contract.VerifyQuote(&_IQuoteVerifier.CallOpts, arg0, arg1)
+}
+
+// VerifyZkOutput is a free data retrieval call binding the contract method 0x9ffa5fd9.
+//
+// Solidity: function verifyZkOutput(bytes ) view returns(bool, bytes)
+func (_IQuoteVerifier *IQuoteVerifierCaller) VerifyZkOutput(opts *bind.CallOpts, arg0 []byte) (bool, []byte, error) {
+	var out []interface{}
+	err := _IQuoteVerifier.contract.Call(opts, &out, "verifyZkOutput", arg0)
+
+	if err != nil {
+		return *new(bool), *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+	out1 := *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return out0, out1, err
+
+}
+
+// VerifyZkOutput is a free data retrieval call binding the contract method 0x9ffa5fd9.
+//
+// Solidity: function verifyZkOutput(bytes ) view returns(bool, bytes)
+func (_IQuoteVerifier *IQuoteVerifierSession) VerifyZkOutput(arg0 []byte) (bool, []byte, error) {
+	return _IQuoteVerifier.Contract.VerifyZkOutput(&_IQuoteVerifier.CallOpts, arg0)
+}
+
+// VerifyZkOutput is a free data retrieval call binding the contract method 0x9ffa5fd9.
+//
+// Solidity: function verifyZkOutput(bytes ) view returns(bool, bytes)
+func (_IQuoteVerifier *IQuoteVerifierCallerSession) VerifyZkOutput(arg0 []byte) (bool, []byte, error) {
+	return _IQuoteVerifier.Contract.VerifyZkOutput(&_IQuoteVerifier.CallOpts, arg0)
+}
+
+// IX509MetaData contains all meta data concerning the IX509 contract.
+var IX509MetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getSubjectPublicKey\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"pubKey\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
+}
+
+// IX509ABI is the input ABI used to generate the binding from.
+// Deprecated: Use IX509MetaData.ABI instead.
+var IX509ABI = IX509MetaData.ABI
+
+// IX509 is an auto generated Go binding around an Ethereum contract.
+type IX509 struct {
+	IX509Caller     // Read-only binding to the contract
+	IX509Transactor // Write-only binding to the contract
+	IX509Filterer   // Log filterer for contract events
+}
+
+// IX509Caller is an auto generated read-only Go binding around an Ethereum contract.
+type IX509Caller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IX509Transactor is an auto generated write-only Go binding around an Ethereum contract.
+type IX509Transactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IX509Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type IX509Filterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// IX509Session is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type IX509Session struct {
+	Contract     *IX509            // 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
+}
+
+// IX509CallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type IX509CallerSession struct {
+	Contract *IX509Caller  // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts // Call options to use throughout this session
+}
+
+// IX509TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type IX509TransactorSession struct {
+	Contract     *IX509Transactor  // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// IX509Raw is an auto generated low-level Go binding around an Ethereum contract.
+type IX509Raw struct {
+	Contract *IX509 // Generic contract binding to access the raw methods on
+}
+
+// IX509CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type IX509CallerRaw struct {
+	Contract *IX509Caller // Generic read-only contract binding to access the raw methods on
+}
+
+// IX509TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type IX509TransactorRaw struct {
+	Contract *IX509Transactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewIX509 creates a new instance of IX509, bound to a specific deployed contract.
+func NewIX509(address common.Address, backend bind.ContractBackend) (*IX509, error) {
+	contract, err := bindIX509(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &IX509{IX509Caller: IX509Caller{contract: contract}, IX509Transactor: IX509Transactor{contract: contract}, IX509Filterer: IX509Filterer{contract: contract}}, nil
+}
+
+// NewIX509Caller creates a new read-only instance of IX509, bound to a specific deployed contract.
+func NewIX509Caller(address common.Address, caller bind.ContractCaller) (*IX509Caller, error) {
+	contract, err := bindIX509(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IX509Caller{contract: contract}, nil
+}
+
+// NewIX509Transactor creates a new write-only instance of IX509, bound to a specific deployed contract.
+func NewIX509Transactor(address common.Address, transactor bind.ContractTransactor) (*IX509Transactor, error) {
+	contract, err := bindIX509(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &IX509Transactor{contract: contract}, nil
+}
+
+// NewIX509Filterer creates a new log filterer instance of IX509, bound to a specific deployed contract.
+func NewIX509Filterer(address common.Address, filterer bind.ContractFilterer) (*IX509Filterer, error) {
+	contract, err := bindIX509(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &IX509Filterer{contract: contract}, nil
+}
+
+// bindIX509 binds a generic wrapper to an already deployed contract.
+func bindIX509(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := IX509MetaData.GetAbi()
+	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 (_IX509 *IX509Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IX509.Contract.IX509Caller.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 (_IX509 *IX509Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IX509.Contract.IX509Transactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IX509 *IX509Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IX509.Contract.IX509Transactor.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 (_IX509 *IX509CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _IX509.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 (_IX509 *IX509TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _IX509.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_IX509 *IX509TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _IX509.Contract.contract.Transact(opts, method, params...)
+}
+
+// GetSubjectPublicKey is a free data retrieval call binding the contract method 0x6d3537a0.
+//
+// Solidity: function getSubjectPublicKey(bytes der) pure returns(bytes pubKey)
+func (_IX509 *IX509Caller) GetSubjectPublicKey(opts *bind.CallOpts, der []byte) ([]byte, error) {
+	var out []interface{}
+	err := _IX509.contract.Call(opts, &out, "getSubjectPublicKey", der)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// GetSubjectPublicKey is a free data retrieval call binding the contract method 0x6d3537a0.
+//
+// Solidity: function getSubjectPublicKey(bytes der) pure returns(bytes pubKey)
+func (_IX509 *IX509Session) GetSubjectPublicKey(der []byte) ([]byte, error) {
+	return _IX509.Contract.GetSubjectPublicKey(&_IX509.CallOpts, der)
+}
+
+// GetSubjectPublicKey is a free data retrieval call binding the contract method 0x6d3537a0.
+//
+// Solidity: function getSubjectPublicKey(bytes der) pure returns(bytes pubKey)
+func (_IX509 *IX509CallerSession) GetSubjectPublicKey(der []byte) ([]byte, error) {
+	return _IX509.Contract.GetSubjectPublicKey(&_IX509.CallOpts, der)
+}
+
+// JSONParserLibMetaData contains all meta data concerning the JSONParserLib contract.
+var JSONParserLibMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"ParsingFailed\",\"type\":\"error\"}]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212205849f99e7f5f941991b84cb8409c837d4c7001e792d073dbd82bb58dafcb0b8464736f6c63430008190033",
+}
+
+// JSONParserLibABI is the input ABI used to generate the binding from.
+// Deprecated: Use JSONParserLibMetaData.ABI instead.
+var JSONParserLibABI = JSONParserLibMetaData.ABI
+
+// JSONParserLibBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use JSONParserLibMetaData.Bin instead.
+var JSONParserLibBin = JSONParserLibMetaData.Bin
+
+// DeployJSONParserLib deploys a new Ethereum contract, binding an instance of JSONParserLib to it.
+func DeployJSONParserLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *JSONParserLib, error) {
+	parsed, err := JSONParserLibMetaData.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(JSONParserLibBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &JSONParserLib{JSONParserLibCaller: JSONParserLibCaller{contract: contract}, JSONParserLibTransactor: JSONParserLibTransactor{contract: contract}, JSONParserLibFilterer: JSONParserLibFilterer{contract: contract}}, nil
+}
+
+// JSONParserLib is an auto generated Go binding around an Ethereum contract.
+type JSONParserLib struct {
+	JSONParserLibCaller     // Read-only binding to the contract
+	JSONParserLibTransactor // Write-only binding to the contract
+	JSONParserLibFilterer   // Log filterer for contract events
+}
+
+// JSONParserLibCaller is an auto generated read-only Go binding around an Ethereum contract.
+type JSONParserLibCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// JSONParserLibTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type JSONParserLibTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// JSONParserLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type JSONParserLibFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// JSONParserLibSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type JSONParserLibSession struct {
+	Contract     *JSONParserLib    // 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
+}
+
+// JSONParserLibCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type JSONParserLibCallerSession struct {
+	Contract *JSONParserLibCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts        // Call options to use throughout this session
+}
+
+// JSONParserLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type JSONParserLibTransactorSession struct {
+	Contract     *JSONParserLibTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
+}
+
+// JSONParserLibRaw is an auto generated low-level Go binding around an Ethereum contract.
+type JSONParserLibRaw struct {
+	Contract *JSONParserLib // Generic contract binding to access the raw methods on
+}
+
+// JSONParserLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type JSONParserLibCallerRaw struct {
+	Contract *JSONParserLibCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// JSONParserLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type JSONParserLibTransactorRaw struct {
+	Contract *JSONParserLibTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewJSONParserLib creates a new instance of JSONParserLib, bound to a specific deployed contract.
+func NewJSONParserLib(address common.Address, backend bind.ContractBackend) (*JSONParserLib, error) {
+	contract, err := bindJSONParserLib(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &JSONParserLib{JSONParserLibCaller: JSONParserLibCaller{contract: contract}, JSONParserLibTransactor: JSONParserLibTransactor{contract: contract}, JSONParserLibFilterer: JSONParserLibFilterer{contract: contract}}, nil
+}
+
+// NewJSONParserLibCaller creates a new read-only instance of JSONParserLib, bound to a specific deployed contract.
+func NewJSONParserLibCaller(address common.Address, caller bind.ContractCaller) (*JSONParserLibCaller, error) {
+	contract, err := bindJSONParserLib(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &JSONParserLibCaller{contract: contract}, nil
+}
+
+// NewJSONParserLibTransactor creates a new write-only instance of JSONParserLib, bound to a specific deployed contract.
+func NewJSONParserLibTransactor(address common.Address, transactor bind.ContractTransactor) (*JSONParserLibTransactor, error) {
+	contract, err := bindJSONParserLib(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &JSONParserLibTransactor{contract: contract}, nil
+}
+
+// NewJSONParserLibFilterer creates a new log filterer instance of JSONParserLib, bound to a specific deployed contract.
+func NewJSONParserLibFilterer(address common.Address, filterer bind.ContractFilterer) (*JSONParserLibFilterer, error) {
+	contract, err := bindJSONParserLib(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &JSONParserLibFilterer{contract: contract}, nil
+}
+
+// bindJSONParserLib binds a generic wrapper to an already deployed contract.
+func bindJSONParserLib(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := JSONParserLibMetaData.GetAbi()
+	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 (_JSONParserLib *JSONParserLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _JSONParserLib.Contract.JSONParserLibCaller.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 (_JSONParserLib *JSONParserLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _JSONParserLib.Contract.JSONParserLibTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_JSONParserLib *JSONParserLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _JSONParserLib.Contract.JSONParserLibTransactor.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 (_JSONParserLib *JSONParserLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _JSONParserLib.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 (_JSONParserLib *JSONParserLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _JSONParserLib.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_JSONParserLib *JSONParserLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _JSONParserLib.Contract.contract.Transact(opts, method, params...)
+}
+
+// LibAsn1PtrMetaData contains all meta data concerning the LibAsn1Ptr contract.
+var LibAsn1PtrMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220bef73236eb41ab9e910f4b8d7febd76a027f260044879f0cafffb429aba140d664736f6c63430008190033",
+}
+
+// LibAsn1PtrABI is the input ABI used to generate the binding from.
+// Deprecated: Use LibAsn1PtrMetaData.ABI instead.
+var LibAsn1PtrABI = LibAsn1PtrMetaData.ABI
+
+// LibAsn1PtrBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use LibAsn1PtrMetaData.Bin instead.
+var LibAsn1PtrBin = LibAsn1PtrMetaData.Bin
+
+// DeployLibAsn1Ptr deploys a new Ethereum contract, binding an instance of LibAsn1Ptr to it.
+func DeployLibAsn1Ptr(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *LibAsn1Ptr, error) {
+	parsed, err := LibAsn1PtrMetaData.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(LibAsn1PtrBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &LibAsn1Ptr{LibAsn1PtrCaller: LibAsn1PtrCaller{contract: contract}, LibAsn1PtrTransactor: LibAsn1PtrTransactor{contract: contract}, LibAsn1PtrFilterer: LibAsn1PtrFilterer{contract: contract}}, nil
+}
+
+// LibAsn1Ptr is an auto generated Go binding around an Ethereum contract.
+type LibAsn1Ptr struct {
+	LibAsn1PtrCaller     // Read-only binding to the contract
+	LibAsn1PtrTransactor // Write-only binding to the contract
+	LibAsn1PtrFilterer   // Log filterer for contract events
+}
+
+// LibAsn1PtrCaller is an auto generated read-only Go binding around an Ethereum contract.
+type LibAsn1PtrCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// LibAsn1PtrTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type LibAsn1PtrTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// LibAsn1PtrFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type LibAsn1PtrFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// LibAsn1PtrSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type LibAsn1PtrSession struct {
+	Contract     *LibAsn1Ptr       // 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
+}
+
+// LibAsn1PtrCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type LibAsn1PtrCallerSession struct {
+	Contract *LibAsn1PtrCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts     // Call options to use throughout this session
+}
+
+// LibAsn1PtrTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type LibAsn1PtrTransactorSession struct {
+	Contract     *LibAsn1PtrTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
+}
+
+// LibAsn1PtrRaw is an auto generated low-level Go binding around an Ethereum contract.
+type LibAsn1PtrRaw struct {
+	Contract *LibAsn1Ptr // Generic contract binding to access the raw methods on
+}
+
+// LibAsn1PtrCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type LibAsn1PtrCallerRaw struct {
+	Contract *LibAsn1PtrCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// LibAsn1PtrTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type LibAsn1PtrTransactorRaw struct {
+	Contract *LibAsn1PtrTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewLibAsn1Ptr creates a new instance of LibAsn1Ptr, bound to a specific deployed contract.
+func NewLibAsn1Ptr(address common.Address, backend bind.ContractBackend) (*LibAsn1Ptr, error) {
+	contract, err := bindLibAsn1Ptr(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &LibAsn1Ptr{LibAsn1PtrCaller: LibAsn1PtrCaller{contract: contract}, LibAsn1PtrTransactor: LibAsn1PtrTransactor{contract: contract}, LibAsn1PtrFilterer: LibAsn1PtrFilterer{contract: contract}}, nil
+}
+
+// NewLibAsn1PtrCaller creates a new read-only instance of LibAsn1Ptr, bound to a specific deployed contract.
+func NewLibAsn1PtrCaller(address common.Address, caller bind.ContractCaller) (*LibAsn1PtrCaller, error) {
+	contract, err := bindLibAsn1Ptr(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &LibAsn1PtrCaller{contract: contract}, nil
+}
+
+// NewLibAsn1PtrTransactor creates a new write-only instance of LibAsn1Ptr, bound to a specific deployed contract.
+func NewLibAsn1PtrTransactor(address common.Address, transactor bind.ContractTransactor) (*LibAsn1PtrTransactor, error) {
+	contract, err := bindLibAsn1Ptr(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &LibAsn1PtrTransactor{contract: contract}, nil
+}
+
+// NewLibAsn1PtrFilterer creates a new log filterer instance of LibAsn1Ptr, bound to a specific deployed contract.
+func NewLibAsn1PtrFilterer(address common.Address, filterer bind.ContractFilterer) (*LibAsn1PtrFilterer, error) {
+	contract, err := bindLibAsn1Ptr(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &LibAsn1PtrFilterer{contract: contract}, nil
+}
+
+// bindLibAsn1Ptr binds a generic wrapper to an already deployed contract.
+func bindLibAsn1Ptr(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := LibAsn1PtrMetaData.GetAbi()
+	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 (_LibAsn1Ptr *LibAsn1PtrRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _LibAsn1Ptr.Contract.LibAsn1PtrCaller.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 (_LibAsn1Ptr *LibAsn1PtrRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _LibAsn1Ptr.Contract.LibAsn1PtrTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_LibAsn1Ptr *LibAsn1PtrRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _LibAsn1Ptr.Contract.LibAsn1PtrTransactor.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 (_LibAsn1Ptr *LibAsn1PtrCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _LibAsn1Ptr.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 (_LibAsn1Ptr *LibAsn1PtrTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _LibAsn1Ptr.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_LibAsn1Ptr *LibAsn1PtrTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _LibAsn1Ptr.Contract.contract.Transact(opts, method, params...)
+}
+
+// LibBytesMetaData contains all meta data concerning the LibBytes contract.
+var LibBytesMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220d146495d7a649153bf9a743e5f711cfcdf1588c188d0873a424ec4c83bdf400e64736f6c63430008190033",
+}
+
+// LibBytesABI is the input ABI used to generate the binding from.
+// Deprecated: Use LibBytesMetaData.ABI instead.
+var LibBytesABI = LibBytesMetaData.ABI
+
+// LibBytesBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use LibBytesMetaData.Bin instead.
+var LibBytesBin = LibBytesMetaData.Bin
+
+// DeployLibBytes deploys a new Ethereum contract, binding an instance of LibBytes to it.
+func DeployLibBytes(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *LibBytes, error) {
+	parsed, err := LibBytesMetaData.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(LibBytesBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &LibBytes{LibBytesCaller: LibBytesCaller{contract: contract}, LibBytesTransactor: LibBytesTransactor{contract: contract}, LibBytesFilterer: LibBytesFilterer{contract: contract}}, nil
+}
+
+// LibBytes is an auto generated Go binding around an Ethereum contract.
+type LibBytes struct {
+	LibBytesCaller     // Read-only binding to the contract
+	LibBytesTransactor // Write-only binding to the contract
+	LibBytesFilterer   // Log filterer for contract events
+}
+
+// LibBytesCaller is an auto generated read-only Go binding around an Ethereum contract.
+type LibBytesCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// LibBytesTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type LibBytesTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// LibBytesFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type LibBytesFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// LibBytesSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type LibBytesSession struct {
+	Contract     *LibBytes         // 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
+}
+
+// LibBytesCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type LibBytesCallerSession struct {
+	Contract *LibBytesCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts   // Call options to use throughout this session
+}
+
+// LibBytesTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type LibBytesTransactorSession struct {
+	Contract     *LibBytesTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
+}
+
+// LibBytesRaw is an auto generated low-level Go binding around an Ethereum contract.
+type LibBytesRaw struct {
+	Contract *LibBytes // Generic contract binding to access the raw methods on
+}
+
+// LibBytesCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type LibBytesCallerRaw struct {
+	Contract *LibBytesCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// LibBytesTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type LibBytesTransactorRaw struct {
+	Contract *LibBytesTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewLibBytes creates a new instance of LibBytes, bound to a specific deployed contract.
+func NewLibBytes(address common.Address, backend bind.ContractBackend) (*LibBytes, error) {
+	contract, err := bindLibBytes(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &LibBytes{LibBytesCaller: LibBytesCaller{contract: contract}, LibBytesTransactor: LibBytesTransactor{contract: contract}, LibBytesFilterer: LibBytesFilterer{contract: contract}}, nil
+}
+
+// NewLibBytesCaller creates a new read-only instance of LibBytes, bound to a specific deployed contract.
+func NewLibBytesCaller(address common.Address, caller bind.ContractCaller) (*LibBytesCaller, error) {
+	contract, err := bindLibBytes(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &LibBytesCaller{contract: contract}, nil
+}
+
+// NewLibBytesTransactor creates a new write-only instance of LibBytes, bound to a specific deployed contract.
+func NewLibBytesTransactor(address common.Address, transactor bind.ContractTransactor) (*LibBytesTransactor, error) {
+	contract, err := bindLibBytes(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &LibBytesTransactor{contract: contract}, nil
+}
+
+// NewLibBytesFilterer creates a new log filterer instance of LibBytes, bound to a specific deployed contract.
+func NewLibBytesFilterer(address common.Address, filterer bind.ContractFilterer) (*LibBytesFilterer, error) {
+	contract, err := bindLibBytes(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &LibBytesFilterer{contract: contract}, nil
+}
+
+// bindLibBytes binds a generic wrapper to an already deployed contract.
+func bindLibBytes(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := LibBytesMetaData.GetAbi()
+	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 (_LibBytes *LibBytesRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _LibBytes.Contract.LibBytesCaller.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 (_LibBytes *LibBytesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _LibBytes.Contract.LibBytesTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_LibBytes *LibBytesRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _LibBytes.Contract.LibBytesTransactor.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 (_LibBytes *LibBytesCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _LibBytes.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 (_LibBytes *LibBytesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _LibBytes.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_LibBytes *LibBytesTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _LibBytes.Contract.contract.Transact(opts, method, params...)
+}
+
+// LibCborElementMetaData contains all meta data concerning the LibCborElement contract.
+var LibCborElementMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212205bc493e62ca9d9d6c5585d12a9346eda7cfabd4d6d5426650c3bb13238a05ca464736f6c63430008190033",
+}
+
+// LibCborElementABI is the input ABI used to generate the binding from.
+// Deprecated: Use LibCborElementMetaData.ABI instead.
+var LibCborElementABI = LibCborElementMetaData.ABI
+
+// LibCborElementBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use LibCborElementMetaData.Bin instead.
+var LibCborElementBin = LibCborElementMetaData.Bin
+
+// DeployLibCborElement deploys a new Ethereum contract, binding an instance of LibCborElement to it.
+func DeployLibCborElement(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *LibCborElement, error) {
+	parsed, err := LibCborElementMetaData.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(LibCborElementBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &LibCborElement{LibCborElementCaller: LibCborElementCaller{contract: contract}, LibCborElementTransactor: LibCborElementTransactor{contract: contract}, LibCborElementFilterer: LibCborElementFilterer{contract: contract}}, nil
+}
+
+// LibCborElement is an auto generated Go binding around an Ethereum contract.
+type LibCborElement struct {
+	LibCborElementCaller     // Read-only binding to the contract
+	LibCborElementTransactor // Write-only binding to the contract
+	LibCborElementFilterer   // Log filterer for contract events
+}
+
+// LibCborElementCaller is an auto generated read-only Go binding around an Ethereum contract.
+type LibCborElementCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// LibCborElementTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type LibCborElementTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// LibCborElementFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type LibCborElementFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// LibCborElementSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type LibCborElementSession struct {
+	Contract     *LibCborElement   // 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
+}
+
+// LibCborElementCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type LibCborElementCallerSession struct {
+	Contract *LibCborElementCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts         // Call options to use throughout this session
+}
+
+// LibCborElementTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type LibCborElementTransactorSession struct {
+	Contract     *LibCborElementTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
+}
+
+// LibCborElementRaw is an auto generated low-level Go binding around an Ethereum contract.
+type LibCborElementRaw struct {
+	Contract *LibCborElement // Generic contract binding to access the raw methods on
+}
+
+// LibCborElementCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type LibCborElementCallerRaw struct {
+	Contract *LibCborElementCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// LibCborElementTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type LibCborElementTransactorRaw struct {
+	Contract *LibCborElementTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewLibCborElement creates a new instance of LibCborElement, bound to a specific deployed contract.
+func NewLibCborElement(address common.Address, backend bind.ContractBackend) (*LibCborElement, error) {
+	contract, err := bindLibCborElement(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &LibCborElement{LibCborElementCaller: LibCborElementCaller{contract: contract}, LibCborElementTransactor: LibCborElementTransactor{contract: contract}, LibCborElementFilterer: LibCborElementFilterer{contract: contract}}, nil
+}
+
+// NewLibCborElementCaller creates a new read-only instance of LibCborElement, bound to a specific deployed contract.
+func NewLibCborElementCaller(address common.Address, caller bind.ContractCaller) (*LibCborElementCaller, error) {
+	contract, err := bindLibCborElement(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &LibCborElementCaller{contract: contract}, nil
+}
+
+// NewLibCborElementTransactor creates a new write-only instance of LibCborElement, bound to a specific deployed contract.
+func NewLibCborElementTransactor(address common.Address, transactor bind.ContractTransactor) (*LibCborElementTransactor, error) {
+	contract, err := bindLibCborElement(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &LibCborElementTransactor{contract: contract}, nil
+}
+
+// NewLibCborElementFilterer creates a new log filterer instance of LibCborElement, bound to a specific deployed contract.
+func NewLibCborElementFilterer(address common.Address, filterer bind.ContractFilterer) (*LibCborElementFilterer, error) {
+	contract, err := bindLibCborElement(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &LibCborElementFilterer{contract: contract}, nil
+}
+
+// bindLibCborElement binds a generic wrapper to an already deployed contract.
+func bindLibCborElement(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := LibCborElementMetaData.GetAbi()
+	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 (_LibCborElement *LibCborElementRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _LibCborElement.Contract.LibCborElementCaller.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 (_LibCborElement *LibCborElementRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _LibCborElement.Contract.LibCborElementTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_LibCborElement *LibCborElementRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _LibCborElement.Contract.LibCborElementTransactor.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 (_LibCborElement *LibCborElementCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _LibCborElement.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 (_LibCborElement *LibCborElementTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _LibCborElement.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_LibCborElement *LibCborElementTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _LibCborElement.Contract.contract.Transact(opts, method, params...)
+}
+
+// LibStringMetaData contains all meta data concerning the LibString contract.
+var LibStringMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"HexLengthInsufficient\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooBigForSmallString\",\"type\":\"error\"}]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212204af5c65dea63954fa075ccb532b000301ccd54bbb4c2faafbedad1a019e2f1c364736f6c63430008190033",
+}
+
+// LibStringABI is the input ABI used to generate the binding from.
+// Deprecated: Use LibStringMetaData.ABI instead.
+var LibStringABI = LibStringMetaData.ABI
+
+// LibStringBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use LibStringMetaData.Bin instead.
+var LibStringBin = LibStringMetaData.Bin
+
+// DeployLibString deploys a new Ethereum contract, binding an instance of LibString to it.
+func DeployLibString(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *LibString, error) {
+	parsed, err := LibStringMetaData.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(LibStringBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &LibString{LibStringCaller: LibStringCaller{contract: contract}, LibStringTransactor: LibStringTransactor{contract: contract}, LibStringFilterer: LibStringFilterer{contract: contract}}, nil
+}
+
+// LibString is an auto generated Go binding around an Ethereum contract.
+type LibString struct {
+	LibStringCaller     // Read-only binding to the contract
+	LibStringTransactor // Write-only binding to the contract
+	LibStringFilterer   // Log filterer for contract events
+}
+
+// LibStringCaller is an auto generated read-only Go binding around an Ethereum contract.
+type LibStringCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// LibStringTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type LibStringTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// LibStringFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type LibStringFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// LibStringSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type LibStringSession struct {
+	Contract     *LibString        // 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
+}
+
+// LibStringCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type LibStringCallerSession struct {
+	Contract *LibStringCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts    // Call options to use throughout this session
+}
+
+// LibStringTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type LibStringTransactorSession struct {
+	Contract     *LibStringTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
+}
+
+// LibStringRaw is an auto generated low-level Go binding around an Ethereum contract.
+type LibStringRaw struct {
+	Contract *LibString // Generic contract binding to access the raw methods on
+}
+
+// LibStringCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type LibStringCallerRaw struct {
+	Contract *LibStringCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// LibStringTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type LibStringTransactorRaw struct {
+	Contract *LibStringTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewLibString creates a new instance of LibString, bound to a specific deployed contract.
+func NewLibString(address common.Address, backend bind.ContractBackend) (*LibString, error) {
+	contract, err := bindLibString(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &LibString{LibStringCaller: LibStringCaller{contract: contract}, LibStringTransactor: LibStringTransactor{contract: contract}, LibStringFilterer: LibStringFilterer{contract: contract}}, nil
+}
+
+// NewLibStringCaller creates a new read-only instance of LibString, bound to a specific deployed contract.
+func NewLibStringCaller(address common.Address, caller bind.ContractCaller) (*LibStringCaller, error) {
+	contract, err := bindLibString(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &LibStringCaller{contract: contract}, nil
+}
+
+// NewLibStringTransactor creates a new write-only instance of LibString, bound to a specific deployed contract.
+func NewLibStringTransactor(address common.Address, transactor bind.ContractTransactor) (*LibStringTransactor, error) {
+	contract, err := bindLibString(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &LibStringTransactor{contract: contract}, nil
+}
+
+// NewLibStringFilterer creates a new log filterer instance of LibString, bound to a specific deployed contract.
+func NewLibStringFilterer(address common.Address, filterer bind.ContractFilterer) (*LibStringFilterer, error) {
+	contract, err := bindLibString(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &LibStringFilterer{contract: contract}, nil
+}
+
+// bindLibString binds a generic wrapper to an already deployed contract.
+func bindLibString(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := LibStringMetaData.GetAbi()
+	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 (_LibString *LibStringRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _LibString.Contract.LibStringCaller.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 (_LibString *LibStringRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _LibString.Contract.LibStringTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_LibString *LibStringRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _LibString.Contract.LibStringTransactor.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 (_LibString *LibStringCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _LibString.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 (_LibString *LibStringTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _LibString.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_LibString *LibStringTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _LibString.Contract.contract.Transact(opts, method, params...)
+}
+
+// MathMetaData contains all meta data concerning the Math contract.
+var MathMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220ce0ff9176bd41cdd6fc9736e052d966dbc0e5e8474c63d32e61a58a3e0e58e9764736f6c63430008190033",
+}
+
+// MathABI is the input ABI used to generate the binding from.
+// Deprecated: Use MathMetaData.ABI instead.
+var MathABI = MathMetaData.ABI
+
+// MathBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use MathMetaData.Bin instead.
+var MathBin = MathMetaData.Bin
+
+// DeployMath deploys a new Ethereum contract, binding an instance of Math to it.
+func DeployMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Math, error) {
+	parsed, err := MathMetaData.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(MathBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &Math{MathCaller: MathCaller{contract: contract}, MathTransactor: MathTransactor{contract: contract}, MathFilterer: MathFilterer{contract: contract}}, nil
+}
+
+// Math is an auto generated Go binding around an Ethereum contract.
+type Math struct {
+	MathCaller     // Read-only binding to the contract
+	MathTransactor // Write-only binding to the contract
+	MathFilterer   // Log filterer for contract events
+}
+
+// MathCaller is an auto generated read-only Go binding around an Ethereum contract.
+type MathCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// MathTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type MathTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// MathFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type MathFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// MathSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type MathSession struct {
+	Contract     *Math             // 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
+}
+
+// MathCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type MathCallerSession struct {
+	Contract *MathCaller   // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts // Call options to use throughout this session
+}
+
+// MathTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type MathTransactorSession struct {
+	Contract     *MathTransactor   // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// MathRaw is an auto generated low-level Go binding around an Ethereum contract.
+type MathRaw struct {
+	Contract *Math // Generic contract binding to access the raw methods on
+}
+
+// MathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type MathCallerRaw struct {
+	Contract *MathCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// MathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type MathTransactorRaw struct {
+	Contract *MathTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewMath creates a new instance of Math, bound to a specific deployed contract.
+func NewMath(address common.Address, backend bind.ContractBackend) (*Math, error) {
+	contract, err := bindMath(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Math{MathCaller: MathCaller{contract: contract}, MathTransactor: MathTransactor{contract: contract}, MathFilterer: MathFilterer{contract: contract}}, nil
+}
+
+// NewMathCaller creates a new read-only instance of Math, bound to a specific deployed contract.
+func NewMathCaller(address common.Address, caller bind.ContractCaller) (*MathCaller, error) {
+	contract, err := bindMath(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &MathCaller{contract: contract}, nil
+}
+
+// NewMathTransactor creates a new write-only instance of Math, bound to a specific deployed contract.
+func NewMathTransactor(address common.Address, transactor bind.ContractTransactor) (*MathTransactor, error) {
+	contract, err := bindMath(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &MathTransactor{contract: contract}, nil
+}
+
+// NewMathFilterer creates a new log filterer instance of Math, bound to a specific deployed contract.
+func NewMathFilterer(address common.Address, filterer bind.ContractFilterer) (*MathFilterer, error) {
+	contract, err := bindMath(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &MathFilterer{contract: contract}, nil
+}
+
+// bindMath binds a generic wrapper to an already deployed contract.
+func bindMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := MathMetaData.GetAbi()
+	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 (_Math *MathRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Math.Contract.MathCaller.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 (_Math *MathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Math.Contract.MathTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Math *MathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Math.Contract.MathTransactor.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 (_Math *MathCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Math.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 (_Math *MathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Math.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Math *MathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Math.Contract.contract.Transact(opts, method, params...)
+}
+
+// MemoryUtilsMetaData contains all meta data concerning the MemoryUtils contract.
+var MemoryUtilsMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea264697066735822122019378bef6326ee1cf2e7b7625f77a96dd78bc5ab8613f2f6850ac12935d0512864736f6c63430008190033",
+}
+
+// MemoryUtilsABI is the input ABI used to generate the binding from.
+// Deprecated: Use MemoryUtilsMetaData.ABI instead.
+var MemoryUtilsABI = MemoryUtilsMetaData.ABI
+
+// MemoryUtilsBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use MemoryUtilsMetaData.Bin instead.
+var MemoryUtilsBin = MemoryUtilsMetaData.Bin
+
+// DeployMemoryUtils deploys a new Ethereum contract, binding an instance of MemoryUtils to it.
+func DeployMemoryUtils(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MemoryUtils, error) {
+	parsed, err := MemoryUtilsMetaData.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(MemoryUtilsBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &MemoryUtils{MemoryUtilsCaller: MemoryUtilsCaller{contract: contract}, MemoryUtilsTransactor: MemoryUtilsTransactor{contract: contract}, MemoryUtilsFilterer: MemoryUtilsFilterer{contract: contract}}, nil
+}
+
+// MemoryUtils is an auto generated Go binding around an Ethereum contract.
+type MemoryUtils struct {
+	MemoryUtilsCaller     // Read-only binding to the contract
+	MemoryUtilsTransactor // Write-only binding to the contract
+	MemoryUtilsFilterer   // Log filterer for contract events
+}
+
+// MemoryUtilsCaller is an auto generated read-only Go binding around an Ethereum contract.
+type MemoryUtilsCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// MemoryUtilsTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type MemoryUtilsTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// MemoryUtilsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type MemoryUtilsFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// MemoryUtilsSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type MemoryUtilsSession struct {
+	Contract     *MemoryUtils      // 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
+}
+
+// MemoryUtilsCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type MemoryUtilsCallerSession struct {
+	Contract *MemoryUtilsCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts      // Call options to use throughout this session
+}
+
+// MemoryUtilsTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type MemoryUtilsTransactorSession struct {
+	Contract     *MemoryUtilsTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts      // Transaction auth options to use throughout this session
+}
+
+// MemoryUtilsRaw is an auto generated low-level Go binding around an Ethereum contract.
+type MemoryUtilsRaw struct {
+	Contract *MemoryUtils // Generic contract binding to access the raw methods on
+}
+
+// MemoryUtilsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type MemoryUtilsCallerRaw struct {
+	Contract *MemoryUtilsCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// MemoryUtilsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type MemoryUtilsTransactorRaw struct {
+	Contract *MemoryUtilsTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewMemoryUtils creates a new instance of MemoryUtils, bound to a specific deployed contract.
+func NewMemoryUtils(address common.Address, backend bind.ContractBackend) (*MemoryUtils, error) {
+	contract, err := bindMemoryUtils(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &MemoryUtils{MemoryUtilsCaller: MemoryUtilsCaller{contract: contract}, MemoryUtilsTransactor: MemoryUtilsTransactor{contract: contract}, MemoryUtilsFilterer: MemoryUtilsFilterer{contract: contract}}, nil
+}
+
+// NewMemoryUtilsCaller creates a new read-only instance of MemoryUtils, bound to a specific deployed contract.
+func NewMemoryUtilsCaller(address common.Address, caller bind.ContractCaller) (*MemoryUtilsCaller, error) {
+	contract, err := bindMemoryUtils(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &MemoryUtilsCaller{contract: contract}, nil
+}
+
+// NewMemoryUtilsTransactor creates a new write-only instance of MemoryUtils, bound to a specific deployed contract.
+func NewMemoryUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*MemoryUtilsTransactor, error) {
+	contract, err := bindMemoryUtils(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &MemoryUtilsTransactor{contract: contract}, nil
+}
+
+// NewMemoryUtilsFilterer creates a new log filterer instance of MemoryUtils, bound to a specific deployed contract.
+func NewMemoryUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*MemoryUtilsFilterer, error) {
+	contract, err := bindMemoryUtils(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &MemoryUtilsFilterer{contract: contract}, nil
+}
+
+// bindMemoryUtils binds a generic wrapper to an already deployed contract.
+func bindMemoryUtils(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := MemoryUtilsMetaData.GetAbi()
+	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 (_MemoryUtils *MemoryUtilsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _MemoryUtils.Contract.MemoryUtilsCaller.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 (_MemoryUtils *MemoryUtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _MemoryUtils.Contract.MemoryUtilsTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_MemoryUtils *MemoryUtilsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _MemoryUtils.Contract.MemoryUtilsTransactor.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 (_MemoryUtils *MemoryUtilsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _MemoryUtils.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 (_MemoryUtils *MemoryUtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _MemoryUtils.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_MemoryUtils *MemoryUtilsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _MemoryUtils.Contract.contract.Transact(opts, method, params...)
+}
+
+// NitroValidatorMetaData contains all meta data concerning the NitroValidator contract.
+var NitroValidatorMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"contractICertManager\",\"name\":\"_certManager\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ATTESTATION_DIGEST\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ATTESTATION_TBS_PREFIX\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CABUNDLE_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CERTIFICATE_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DIGEST_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MODULE_ID_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"NONCE_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PCRS_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PUBLIC_KEY_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"TIMESTAMP_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"USER_DATA_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"certManager\",\"outputs\":[{\"internalType\":\"contractICertManager\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"attestation\",\"type\":\"bytes\"}],\"name\":\"decodeAttestationTbs\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"attestationTbs\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"attestationTbs\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"validateAttestation\",\"outputs\":[{\"components\":[{\"internalType\":\"CborElement\",\"name\":\"moduleID\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"timestamp\",\"type\":\"uint64\"},{\"internalType\":\"CborElement\",\"name\":\"digest\",\"type\":\"uint256\"},{\"internalType\":\"CborElement[]\",\"name\":\"pcrs\",\"type\":\"uint256[]\"},{\"internalType\":\"CborElement\",\"name\":\"cert\",\"type\":\"uint256\"},{\"internalType\":\"CborElement[]\",\"name\":\"cabundle\",\"type\":\"uint256[]\"},{\"internalType\":\"CborElement\",\"name\":\"publicKey\",\"type\":\"uint256\"},{\"internalType\":\"CborElement\",\"name\":\"userData\",\"type\":\"uint256\"},{\"internalType\":\"CborElement\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"internalType\":\"structNitroValidator.Ptrs\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
+	Bin: "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",
+}
+
+// NitroValidatorABI is the input ABI used to generate the binding from.
+// Deprecated: Use NitroValidatorMetaData.ABI instead.
+var NitroValidatorABI = NitroValidatorMetaData.ABI
+
+// NitroValidatorBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use NitroValidatorMetaData.Bin instead.
+var NitroValidatorBin = NitroValidatorMetaData.Bin
+
+// DeployNitroValidator deploys a new Ethereum contract, binding an instance of NitroValidator to it.
+func DeployNitroValidator(auth *bind.TransactOpts, backend bind.ContractBackend, _certManager common.Address) (common.Address, *types.Transaction, *NitroValidator, error) {
+	parsed, err := NitroValidatorMetaData.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(NitroValidatorBin), backend, _certManager)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &NitroValidator{NitroValidatorCaller: NitroValidatorCaller{contract: contract}, NitroValidatorTransactor: NitroValidatorTransactor{contract: contract}, NitroValidatorFilterer: NitroValidatorFilterer{contract: contract}}, nil
+}
+
+// NitroValidator is an auto generated Go binding around an Ethereum contract.
+type NitroValidator struct {
+	NitroValidatorCaller     // Read-only binding to the contract
+	NitroValidatorTransactor // Write-only binding to the contract
+	NitroValidatorFilterer   // Log filterer for contract events
+}
+
+// NitroValidatorCaller is an auto generated read-only Go binding around an Ethereum contract.
+type NitroValidatorCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// NitroValidatorTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type NitroValidatorTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// NitroValidatorFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type NitroValidatorFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// NitroValidatorSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type NitroValidatorSession struct {
+	Contract     *NitroValidator   // 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
+}
+
+// NitroValidatorCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type NitroValidatorCallerSession struct {
+	Contract *NitroValidatorCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts         // Call options to use throughout this session
+}
+
+// NitroValidatorTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type NitroValidatorTransactorSession struct {
+	Contract     *NitroValidatorTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
+}
+
+// NitroValidatorRaw is an auto generated low-level Go binding around an Ethereum contract.
+type NitroValidatorRaw struct {
+	Contract *NitroValidator // Generic contract binding to access the raw methods on
+}
+
+// NitroValidatorCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type NitroValidatorCallerRaw struct {
+	Contract *NitroValidatorCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// NitroValidatorTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type NitroValidatorTransactorRaw struct {
+	Contract *NitroValidatorTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewNitroValidator creates a new instance of NitroValidator, bound to a specific deployed contract.
+func NewNitroValidator(address common.Address, backend bind.ContractBackend) (*NitroValidator, error) {
+	contract, err := bindNitroValidator(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &NitroValidator{NitroValidatorCaller: NitroValidatorCaller{contract: contract}, NitroValidatorTransactor: NitroValidatorTransactor{contract: contract}, NitroValidatorFilterer: NitroValidatorFilterer{contract: contract}}, nil
+}
+
+// NewNitroValidatorCaller creates a new read-only instance of NitroValidator, bound to a specific deployed contract.
+func NewNitroValidatorCaller(address common.Address, caller bind.ContractCaller) (*NitroValidatorCaller, error) {
+	contract, err := bindNitroValidator(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &NitroValidatorCaller{contract: contract}, nil
+}
+
+// NewNitroValidatorTransactor creates a new write-only instance of NitroValidator, bound to a specific deployed contract.
+func NewNitroValidatorTransactor(address common.Address, transactor bind.ContractTransactor) (*NitroValidatorTransactor, error) {
+	contract, err := bindNitroValidator(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &NitroValidatorTransactor{contract: contract}, nil
+}
+
+// NewNitroValidatorFilterer creates a new log filterer instance of NitroValidator, bound to a specific deployed contract.
+func NewNitroValidatorFilterer(address common.Address, filterer bind.ContractFilterer) (*NitroValidatorFilterer, error) {
+	contract, err := bindNitroValidator(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &NitroValidatorFilterer{contract: contract}, nil
+}
+
+// bindNitroValidator binds a generic wrapper to an already deployed contract.
+func bindNitroValidator(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := NitroValidatorMetaData.GetAbi()
+	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 (_NitroValidator *NitroValidatorRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _NitroValidator.Contract.NitroValidatorCaller.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 (_NitroValidator *NitroValidatorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _NitroValidator.Contract.NitroValidatorTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_NitroValidator *NitroValidatorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _NitroValidator.Contract.NitroValidatorTransactor.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 (_NitroValidator *NitroValidatorCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _NitroValidator.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 (_NitroValidator *NitroValidatorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _NitroValidator.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_NitroValidator *NitroValidatorTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _NitroValidator.Contract.contract.Transact(opts, method, params...)
+}
+
+// ATTESTATIONDIGEST is a free data retrieval call binding the contract method 0x3893af6d.
+//
+// Solidity: function ATTESTATION_DIGEST() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCaller) ATTESTATIONDIGEST(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _NitroValidator.contract.Call(opts, &out, "ATTESTATION_DIGEST")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// ATTESTATIONDIGEST is a free data retrieval call binding the contract method 0x3893af6d.
+//
+// Solidity: function ATTESTATION_DIGEST() view returns(bytes32)
+func (_NitroValidator *NitroValidatorSession) ATTESTATIONDIGEST() ([32]byte, error) {
+	return _NitroValidator.Contract.ATTESTATIONDIGEST(&_NitroValidator.CallOpts)
+}
+
+// ATTESTATIONDIGEST is a free data retrieval call binding the contract method 0x3893af6d.
+//
+// Solidity: function ATTESTATION_DIGEST() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCallerSession) ATTESTATIONDIGEST() ([32]byte, error) {
+	return _NitroValidator.Contract.ATTESTATIONDIGEST(&_NitroValidator.CallOpts)
+}
+
+// ATTESTATIONTBSPREFIX is a free data retrieval call binding the contract method 0x2d4bad8a.
+//
+// Solidity: function ATTESTATION_TBS_PREFIX() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCaller) ATTESTATIONTBSPREFIX(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _NitroValidator.contract.Call(opts, &out, "ATTESTATION_TBS_PREFIX")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// ATTESTATIONTBSPREFIX is a free data retrieval call binding the contract method 0x2d4bad8a.
+//
+// Solidity: function ATTESTATION_TBS_PREFIX() view returns(bytes32)
+func (_NitroValidator *NitroValidatorSession) ATTESTATIONTBSPREFIX() ([32]byte, error) {
+	return _NitroValidator.Contract.ATTESTATIONTBSPREFIX(&_NitroValidator.CallOpts)
+}
+
+// ATTESTATIONTBSPREFIX is a free data retrieval call binding the contract method 0x2d4bad8a.
+//
+// Solidity: function ATTESTATION_TBS_PREFIX() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCallerSession) ATTESTATIONTBSPREFIX() ([32]byte, error) {
+	return _NitroValidator.Contract.ATTESTATIONTBSPREFIX(&_NitroValidator.CallOpts)
+}
+
+// CABUNDLEKEY is a free data retrieval call binding the contract method 0x9cc3eb48.
+//
+// Solidity: function CABUNDLE_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCaller) CABUNDLEKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _NitroValidator.contract.Call(opts, &out, "CABUNDLE_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// CABUNDLEKEY is a free data retrieval call binding the contract method 0x9cc3eb48.
+//
+// Solidity: function CABUNDLE_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorSession) CABUNDLEKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.CABUNDLEKEY(&_NitroValidator.CallOpts)
+}
+
+// CABUNDLEKEY is a free data retrieval call binding the contract method 0x9cc3eb48.
+//
+// Solidity: function CABUNDLE_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCallerSession) CABUNDLEKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.CABUNDLEKEY(&_NitroValidator.CallOpts)
+}
+
+// CERTIFICATEKEY is a free data retrieval call binding the contract method 0xae951149.
+//
+// Solidity: function CERTIFICATE_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCaller) CERTIFICATEKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _NitroValidator.contract.Call(opts, &out, "CERTIFICATE_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// CERTIFICATEKEY is a free data retrieval call binding the contract method 0xae951149.
+//
+// Solidity: function CERTIFICATE_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorSession) CERTIFICATEKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.CERTIFICATEKEY(&_NitroValidator.CallOpts)
+}
+
+// CERTIFICATEKEY is a free data retrieval call binding the contract method 0xae951149.
+//
+// Solidity: function CERTIFICATE_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCallerSession) CERTIFICATEKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.CERTIFICATEKEY(&_NitroValidator.CallOpts)
+}
+
+// DIGESTKEY is a free data retrieval call binding the contract method 0x6be1e68b.
+//
+// Solidity: function DIGEST_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCaller) DIGESTKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _NitroValidator.contract.Call(opts, &out, "DIGEST_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// DIGESTKEY is a free data retrieval call binding the contract method 0x6be1e68b.
+//
+// Solidity: function DIGEST_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorSession) DIGESTKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.DIGESTKEY(&_NitroValidator.CallOpts)
+}
+
+// DIGESTKEY is a free data retrieval call binding the contract method 0x6be1e68b.
+//
+// Solidity: function DIGEST_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCallerSession) DIGESTKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.DIGESTKEY(&_NitroValidator.CallOpts)
+}
+
+// MODULEIDKEY is a free data retrieval call binding the contract method 0x9adb2d68.
+//
+// Solidity: function MODULE_ID_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCaller) MODULEIDKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _NitroValidator.contract.Call(opts, &out, "MODULE_ID_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// MODULEIDKEY is a free data retrieval call binding the contract method 0x9adb2d68.
+//
+// Solidity: function MODULE_ID_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorSession) MODULEIDKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.MODULEIDKEY(&_NitroValidator.CallOpts)
+}
+
+// MODULEIDKEY is a free data retrieval call binding the contract method 0x9adb2d68.
+//
+// Solidity: function MODULE_ID_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCallerSession) MODULEIDKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.MODULEIDKEY(&_NitroValidator.CallOpts)
+}
+
+// NONCEKEY is a free data retrieval call binding the contract method 0x6378aad5.
+//
+// Solidity: function NONCE_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCaller) NONCEKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _NitroValidator.contract.Call(opts, &out, "NONCE_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// NONCEKEY is a free data retrieval call binding the contract method 0x6378aad5.
+//
+// Solidity: function NONCE_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorSession) NONCEKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.NONCEKEY(&_NitroValidator.CallOpts)
+}
+
+// NONCEKEY is a free data retrieval call binding the contract method 0x6378aad5.
+//
+// Solidity: function NONCE_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCallerSession) NONCEKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.NONCEKEY(&_NitroValidator.CallOpts)
+}
+
+// PCRSKEY is a free data retrieval call binding the contract method 0xb22bed7e.
+//
+// Solidity: function PCRS_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCaller) PCRSKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _NitroValidator.contract.Call(opts, &out, "PCRS_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// PCRSKEY is a free data retrieval call binding the contract method 0xb22bed7e.
+//
+// Solidity: function PCRS_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorSession) PCRSKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.PCRSKEY(&_NitroValidator.CallOpts)
+}
+
+// PCRSKEY is a free data retrieval call binding the contract method 0xb22bed7e.
+//
+// Solidity: function PCRS_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCallerSession) PCRSKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.PCRSKEY(&_NitroValidator.CallOpts)
+}
+
+// PUBLICKEYKEY is a free data retrieval call binding the contract method 0xe8b6d3fe.
+//
+// Solidity: function PUBLIC_KEY_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCaller) PUBLICKEYKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _NitroValidator.contract.Call(opts, &out, "PUBLIC_KEY_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// PUBLICKEYKEY is a free data retrieval call binding the contract method 0xe8b6d3fe.
+//
+// Solidity: function PUBLIC_KEY_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorSession) PUBLICKEYKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.PUBLICKEYKEY(&_NitroValidator.CallOpts)
+}
+
+// PUBLICKEYKEY is a free data retrieval call binding the contract method 0xe8b6d3fe.
+//
+// Solidity: function PUBLIC_KEY_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCallerSession) PUBLICKEYKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.PUBLICKEYKEY(&_NitroValidator.CallOpts)
+}
+
+// TIMESTAMPKEY is a free data retrieval call binding the contract method 0xe0a655ff.
+//
+// Solidity: function TIMESTAMP_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCaller) TIMESTAMPKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _NitroValidator.contract.Call(opts, &out, "TIMESTAMP_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// TIMESTAMPKEY is a free data retrieval call binding the contract method 0xe0a655ff.
+//
+// Solidity: function TIMESTAMP_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorSession) TIMESTAMPKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.TIMESTAMPKEY(&_NitroValidator.CallOpts)
+}
+
+// TIMESTAMPKEY is a free data retrieval call binding the contract method 0xe0a655ff.
+//
+// Solidity: function TIMESTAMP_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCallerSession) TIMESTAMPKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.TIMESTAMPKEY(&_NitroValidator.CallOpts)
+}
+
+// USERDATAKEY is a free data retrieval call binding the contract method 0xcebf08d7.
+//
+// Solidity: function USER_DATA_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCaller) USERDATAKEY(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _NitroValidator.contract.Call(opts, &out, "USER_DATA_KEY")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// USERDATAKEY is a free data retrieval call binding the contract method 0xcebf08d7.
+//
+// Solidity: function USER_DATA_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorSession) USERDATAKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.USERDATAKEY(&_NitroValidator.CallOpts)
+}
+
+// USERDATAKEY is a free data retrieval call binding the contract method 0xcebf08d7.
+//
+// Solidity: function USER_DATA_KEY() view returns(bytes32)
+func (_NitroValidator *NitroValidatorCallerSession) USERDATAKEY() ([32]byte, error) {
+	return _NitroValidator.Contract.USERDATAKEY(&_NitroValidator.CallOpts)
+}
+
+// CertManager is a free data retrieval call binding the contract method 0x739e8484.
+//
+// Solidity: function certManager() view returns(address)
+func (_NitroValidator *NitroValidatorCaller) CertManager(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _NitroValidator.contract.Call(opts, &out, "certManager")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// CertManager is a free data retrieval call binding the contract method 0x739e8484.
+//
+// Solidity: function certManager() view returns(address)
+func (_NitroValidator *NitroValidatorSession) CertManager() (common.Address, error) {
+	return _NitroValidator.Contract.CertManager(&_NitroValidator.CallOpts)
+}
+
+// CertManager is a free data retrieval call binding the contract method 0x739e8484.
+//
+// Solidity: function certManager() view returns(address)
+func (_NitroValidator *NitroValidatorCallerSession) CertManager() (common.Address, error) {
+	return _NitroValidator.Contract.CertManager(&_NitroValidator.CallOpts)
+}
+
+// DecodeAttestationTbs is a free data retrieval call binding the contract method 0xa903a277.
+//
+// Solidity: function decodeAttestationTbs(bytes attestation) pure returns(bytes attestationTbs, bytes signature)
+func (_NitroValidator *NitroValidatorCaller) DecodeAttestationTbs(opts *bind.CallOpts, attestation []byte) (struct {
+	AttestationTbs []byte
+	Signature      []byte
+}, error) {
+	var out []interface{}
+	err := _NitroValidator.contract.Call(opts, &out, "decodeAttestationTbs", attestation)
+
+	outstruct := new(struct {
+		AttestationTbs []byte
+		Signature      []byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.AttestationTbs = *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+	outstruct.Signature = *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return *outstruct, err
+
+}
+
+// DecodeAttestationTbs is a free data retrieval call binding the contract method 0xa903a277.
+//
+// Solidity: function decodeAttestationTbs(bytes attestation) pure returns(bytes attestationTbs, bytes signature)
+func (_NitroValidator *NitroValidatorSession) DecodeAttestationTbs(attestation []byte) (struct {
+	AttestationTbs []byte
+	Signature      []byte
+}, error) {
+	return _NitroValidator.Contract.DecodeAttestationTbs(&_NitroValidator.CallOpts, attestation)
+}
+
+// DecodeAttestationTbs is a free data retrieval call binding the contract method 0xa903a277.
+//
+// Solidity: function decodeAttestationTbs(bytes attestation) pure returns(bytes attestationTbs, bytes signature)
+func (_NitroValidator *NitroValidatorCallerSession) DecodeAttestationTbs(attestation []byte) (struct {
+	AttestationTbs []byte
+	Signature      []byte
+}, error) {
+	return _NitroValidator.Contract.DecodeAttestationTbs(&_NitroValidator.CallOpts, attestation)
+}
+
+// ValidateAttestation is a paid mutator transaction binding the contract method 0x05f7aead.
+//
+// Solidity: function validateAttestation(bytes attestationTbs, bytes signature) returns((uint256,uint64,uint256,uint256[],uint256,uint256[],uint256,uint256,uint256))
+func (_NitroValidator *NitroValidatorTransactor) ValidateAttestation(opts *bind.TransactOpts, attestationTbs []byte, signature []byte) (*types.Transaction, error) {
+	return _NitroValidator.contract.Transact(opts, "validateAttestation", attestationTbs, signature)
+}
+
+// ValidateAttestation is a paid mutator transaction binding the contract method 0x05f7aead.
+//
+// Solidity: function validateAttestation(bytes attestationTbs, bytes signature) returns((uint256,uint64,uint256,uint256[],uint256,uint256[],uint256,uint256,uint256))
+func (_NitroValidator *NitroValidatorSession) ValidateAttestation(attestationTbs []byte, signature []byte) (*types.Transaction, error) {
+	return _NitroValidator.Contract.ValidateAttestation(&_NitroValidator.TransactOpts, attestationTbs, signature)
+}
+
+// ValidateAttestation is a paid mutator transaction binding the contract method 0x05f7aead.
+//
+// Solidity: function validateAttestation(bytes attestationTbs, bytes signature) returns((uint256,uint64,uint256,uint256[],uint256,uint256[],uint256,uint256,uint256))
+func (_NitroValidator *NitroValidatorTransactorSession) ValidateAttestation(attestationTbs []byte, signature []byte) (*types.Transaction, error) {
+	return _NitroValidator.Contract.ValidateAttestation(&_NitroValidator.TransactOpts, attestationTbs, signature)
+}
+
+// NodePtrMetaData contains all meta data concerning the NodePtr contract.
+var NodePtrMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220004bc26aaa89e713e54cebdca583d07f19ec43e7fa23cd43deff7514ba35692864736f6c63430008190033",
+}
+
+// NodePtrABI is the input ABI used to generate the binding from.
+// Deprecated: Use NodePtrMetaData.ABI instead.
+var NodePtrABI = NodePtrMetaData.ABI
+
+// NodePtrBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use NodePtrMetaData.Bin instead.
+var NodePtrBin = NodePtrMetaData.Bin
+
+// DeployNodePtr deploys a new Ethereum contract, binding an instance of NodePtr to it.
+func DeployNodePtr(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *NodePtr, error) {
+	parsed, err := NodePtrMetaData.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(NodePtrBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &NodePtr{NodePtrCaller: NodePtrCaller{contract: contract}, NodePtrTransactor: NodePtrTransactor{contract: contract}, NodePtrFilterer: NodePtrFilterer{contract: contract}}, nil
+}
+
+// NodePtr is an auto generated Go binding around an Ethereum contract.
+type NodePtr struct {
+	NodePtrCaller     // Read-only binding to the contract
+	NodePtrTransactor // Write-only binding to the contract
+	NodePtrFilterer   // Log filterer for contract events
+}
+
+// NodePtrCaller is an auto generated read-only Go binding around an Ethereum contract.
+type NodePtrCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// NodePtrTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type NodePtrTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// NodePtrFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type NodePtrFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// NodePtrSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type NodePtrSession struct {
+	Contract     *NodePtr          // 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
+}
+
+// NodePtrCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type NodePtrCallerSession struct {
+	Contract *NodePtrCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts  // Call options to use throughout this session
+}
+
+// NodePtrTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type NodePtrTransactorSession struct {
+	Contract     *NodePtrTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
+}
+
+// NodePtrRaw is an auto generated low-level Go binding around an Ethereum contract.
+type NodePtrRaw struct {
+	Contract *NodePtr // Generic contract binding to access the raw methods on
+}
+
+// NodePtrCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type NodePtrCallerRaw struct {
+	Contract *NodePtrCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// NodePtrTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type NodePtrTransactorRaw struct {
+	Contract *NodePtrTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewNodePtr creates a new instance of NodePtr, bound to a specific deployed contract.
+func NewNodePtr(address common.Address, backend bind.ContractBackend) (*NodePtr, error) {
+	contract, err := bindNodePtr(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &NodePtr{NodePtrCaller: NodePtrCaller{contract: contract}, NodePtrTransactor: NodePtrTransactor{contract: contract}, NodePtrFilterer: NodePtrFilterer{contract: contract}}, nil
+}
+
+// NewNodePtrCaller creates a new read-only instance of NodePtr, bound to a specific deployed contract.
+func NewNodePtrCaller(address common.Address, caller bind.ContractCaller) (*NodePtrCaller, error) {
+	contract, err := bindNodePtr(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &NodePtrCaller{contract: contract}, nil
+}
+
+// NewNodePtrTransactor creates a new write-only instance of NodePtr, bound to a specific deployed contract.
+func NewNodePtrTransactor(address common.Address, transactor bind.ContractTransactor) (*NodePtrTransactor, error) {
+	contract, err := bindNodePtr(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &NodePtrTransactor{contract: contract}, nil
+}
+
+// NewNodePtrFilterer creates a new log filterer instance of NodePtr, bound to a specific deployed contract.
+func NewNodePtrFilterer(address common.Address, filterer bind.ContractFilterer) (*NodePtrFilterer, error) {
+	contract, err := bindNodePtr(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &NodePtrFilterer{contract: contract}, nil
+}
+
+// bindNodePtr binds a generic wrapper to an already deployed contract.
+func bindNodePtr(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := NodePtrMetaData.GetAbi()
+	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 (_NodePtr *NodePtrRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _NodePtr.Contract.NodePtrCaller.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 (_NodePtr *NodePtrRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _NodePtr.Contract.NodePtrTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_NodePtr *NodePtrRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _NodePtr.Contract.NodePtrTransactor.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 (_NodePtr *NodePtrCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _NodePtr.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 (_NodePtr *NodePtrTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _NodePtr.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_NodePtr *NodePtrTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _NodePtr.Contract.contract.Transact(opts, method, params...)
+}
+
+// OwnableMetaData contains all meta data concerning the Ownable contract.
+var OwnableMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"}]",
+}
+
+// OwnableABI is the input ABI used to generate the binding from.
+// Deprecated: Use OwnableMetaData.ABI instead.
+var OwnableABI = OwnableMetaData.ABI
+
+// Ownable is an auto generated Go binding around an Ethereum contract.
+type Ownable struct {
+	OwnableCaller     // Read-only binding to the contract
+	OwnableTransactor // Write-only binding to the contract
+	OwnableFilterer   // Log filterer for contract events
+}
+
+// OwnableCaller is an auto generated read-only Go binding around an Ethereum contract.
+type OwnableCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// OwnableTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type OwnableTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// OwnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type OwnableFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// OwnableSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type OwnableSession struct {
+	Contract     *Ownable          // 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
+}
+
+// OwnableCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type OwnableCallerSession struct {
+	Contract *OwnableCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts  // Call options to use throughout this session
+}
+
+// OwnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type OwnableTransactorSession struct {
+	Contract     *OwnableTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
+}
+
+// OwnableRaw is an auto generated low-level Go binding around an Ethereum contract.
+type OwnableRaw struct {
+	Contract *Ownable // Generic contract binding to access the raw methods on
+}
+
+// OwnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type OwnableCallerRaw struct {
+	Contract *OwnableCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// OwnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type OwnableTransactorRaw struct {
+	Contract *OwnableTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewOwnable creates a new instance of Ownable, bound to a specific deployed contract.
+func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error) {
+	contract, err := bindOwnable(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Ownable{OwnableCaller: OwnableCaller{contract: contract}, OwnableTransactor: OwnableTransactor{contract: contract}, OwnableFilterer: OwnableFilterer{contract: contract}}, nil
+}
+
+// NewOwnableCaller creates a new read-only instance of Ownable, bound to a specific deployed contract.
+func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error) {
+	contract, err := bindOwnable(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &OwnableCaller{contract: contract}, nil
+}
+
+// NewOwnableTransactor creates a new write-only instance of Ownable, bound to a specific deployed contract.
+func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error) {
+	contract, err := bindOwnable(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &OwnableTransactor{contract: contract}, nil
+}
+
+// NewOwnableFilterer creates a new log filterer instance of Ownable, bound to a specific deployed contract.
+func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error) {
+	contract, err := bindOwnable(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &OwnableFilterer{contract: contract}, nil
+}
+
+// bindOwnable binds a generic wrapper to an already deployed contract.
+func bindOwnable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := OwnableMetaData.GetAbi()
+	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 (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Ownable.Contract.OwnableCaller.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 (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Ownable.Contract.OwnableTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Ownable.Contract.OwnableTransactor.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 (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Ownable.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 (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Ownable.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Ownable.Contract.contract.Transact(opts, method, params...)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _Ownable.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 (_Ownable *OwnableSession) Owner() (common.Address, error) {
+	return _Ownable.Contract.Owner(&_Ownable.CallOpts)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_Ownable *OwnableCallerSession) Owner() (common.Address, error) {
+	return _Ownable.Contract.Owner(&_Ownable.CallOpts)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Ownable.contract.Transact(opts, "renounceOwnership")
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error) {
+	return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error) {
+	return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
+	return _Ownable.contract.Transact(opts, "transferOwnership", newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner)
+}
+
+// OwnableOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Ownable contract.
+type OwnableOwnershipTransferredIterator struct {
+	Event *OwnableOwnershipTransferred // 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 *OwnableOwnershipTransferredIterator) 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(OwnableOwnershipTransferred)
+			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(OwnableOwnershipTransferred)
+		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 *OwnableOwnershipTransferredIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *OwnableOwnershipTransferredIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract.
+type OwnableOwnershipTransferred 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 (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OwnableOwnershipTransferredIterator, 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 := _Ownable.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return &OwnableOwnershipTransferredIterator{contract: _Ownable.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 (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, 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 := _Ownable.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(OwnableOwnershipTransferred)
+				if err := _Ownable.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 (_Ownable *OwnableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableOwnershipTransferred, error) {
+	event := new(OwnableOwnershipTransferred)
+	if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// Ownable2StepMetaData contains all meta data concerning the Ownable2Step contract.
+var Ownable2StepMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"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\"}]",
+}
+
+// Ownable2StepABI is the input ABI used to generate the binding from.
+// Deprecated: Use Ownable2StepMetaData.ABI instead.
+var Ownable2StepABI = Ownable2StepMetaData.ABI
+
+// Ownable2Step is an auto generated Go binding around an Ethereum contract.
+type Ownable2Step struct {
+	Ownable2StepCaller     // Read-only binding to the contract
+	Ownable2StepTransactor // Write-only binding to the contract
+	Ownable2StepFilterer   // Log filterer for contract events
+}
+
+// Ownable2StepCaller is an auto generated read-only Go binding around an Ethereum contract.
+type Ownable2StepCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Ownable2StepTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type Ownable2StepTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Ownable2StepFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type Ownable2StepFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Ownable2StepSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type Ownable2StepSession struct {
+	Contract     *Ownable2Step     // 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
+}
+
+// Ownable2StepCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type Ownable2StepCallerSession struct {
+	Contract *Ownable2StepCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts       // Call options to use throughout this session
+}
+
+// Ownable2StepTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type Ownable2StepTransactorSession struct {
+	Contract     *Ownable2StepTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
+}
+
+// Ownable2StepRaw is an auto generated low-level Go binding around an Ethereum contract.
+type Ownable2StepRaw struct {
+	Contract *Ownable2Step // Generic contract binding to access the raw methods on
+}
+
+// Ownable2StepCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type Ownable2StepCallerRaw struct {
+	Contract *Ownable2StepCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// Ownable2StepTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type Ownable2StepTransactorRaw struct {
+	Contract *Ownable2StepTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewOwnable2Step creates a new instance of Ownable2Step, bound to a specific deployed contract.
+func NewOwnable2Step(address common.Address, backend bind.ContractBackend) (*Ownable2Step, error) {
+	contract, err := bindOwnable2Step(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Ownable2Step{Ownable2StepCaller: Ownable2StepCaller{contract: contract}, Ownable2StepTransactor: Ownable2StepTransactor{contract: contract}, Ownable2StepFilterer: Ownable2StepFilterer{contract: contract}}, nil
+}
+
+// NewOwnable2StepCaller creates a new read-only instance of Ownable2Step, bound to a specific deployed contract.
+func NewOwnable2StepCaller(address common.Address, caller bind.ContractCaller) (*Ownable2StepCaller, error) {
+	contract, err := bindOwnable2Step(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &Ownable2StepCaller{contract: contract}, nil
+}
+
+// NewOwnable2StepTransactor creates a new write-only instance of Ownable2Step, bound to a specific deployed contract.
+func NewOwnable2StepTransactor(address common.Address, transactor bind.ContractTransactor) (*Ownable2StepTransactor, error) {
+	contract, err := bindOwnable2Step(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &Ownable2StepTransactor{contract: contract}, nil
+}
+
+// NewOwnable2StepFilterer creates a new log filterer instance of Ownable2Step, bound to a specific deployed contract.
+func NewOwnable2StepFilterer(address common.Address, filterer bind.ContractFilterer) (*Ownable2StepFilterer, error) {
+	contract, err := bindOwnable2Step(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &Ownable2StepFilterer{contract: contract}, nil
+}
+
+// bindOwnable2Step binds a generic wrapper to an already deployed contract.
+func bindOwnable2Step(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := Ownable2StepMetaData.GetAbi()
+	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 (_Ownable2Step *Ownable2StepRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Ownable2Step.Contract.Ownable2StepCaller.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 (_Ownable2Step *Ownable2StepRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Ownable2Step.Contract.Ownable2StepTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Ownable2Step *Ownable2StepRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Ownable2Step.Contract.Ownable2StepTransactor.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 (_Ownable2Step *Ownable2StepCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Ownable2Step.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 (_Ownable2Step *Ownable2StepTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Ownable2Step.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Ownable2Step *Ownable2StepTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Ownable2Step.Contract.contract.Transact(opts, method, params...)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_Ownable2Step *Ownable2StepCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _Ownable2Step.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 (_Ownable2Step *Ownable2StepSession) Owner() (common.Address, error) {
+	return _Ownable2Step.Contract.Owner(&_Ownable2Step.CallOpts)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_Ownable2Step *Ownable2StepCallerSession) Owner() (common.Address, error) {
+	return _Ownable2Step.Contract.Owner(&_Ownable2Step.CallOpts)
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_Ownable2Step *Ownable2StepCaller) PendingOwner(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _Ownable2Step.contract.Call(opts, &out, "pendingOwner")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_Ownable2Step *Ownable2StepSession) PendingOwner() (common.Address, error) {
+	return _Ownable2Step.Contract.PendingOwner(&_Ownable2Step.CallOpts)
+}
+
+// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978.
+//
+// Solidity: function pendingOwner() view returns(address)
+func (_Ownable2Step *Ownable2StepCallerSession) PendingOwner() (common.Address, error) {
+	return _Ownable2Step.Contract.PendingOwner(&_Ownable2Step.CallOpts)
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_Ownable2Step *Ownable2StepTransactor) AcceptOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Ownable2Step.contract.Transact(opts, "acceptOwnership")
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_Ownable2Step *Ownable2StepSession) AcceptOwnership() (*types.Transaction, error) {
+	return _Ownable2Step.Contract.AcceptOwnership(&_Ownable2Step.TransactOpts)
+}
+
+// AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
+//
+// Solidity: function acceptOwnership() returns()
+func (_Ownable2Step *Ownable2StepTransactorSession) AcceptOwnership() (*types.Transaction, error) {
+	return _Ownable2Step.Contract.AcceptOwnership(&_Ownable2Step.TransactOpts)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_Ownable2Step *Ownable2StepTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Ownable2Step.contract.Transact(opts, "renounceOwnership")
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_Ownable2Step *Ownable2StepSession) RenounceOwnership() (*types.Transaction, error) {
+	return _Ownable2Step.Contract.RenounceOwnership(&_Ownable2Step.TransactOpts)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_Ownable2Step *Ownable2StepTransactorSession) RenounceOwnership() (*types.Transaction, error) {
+	return _Ownable2Step.Contract.RenounceOwnership(&_Ownable2Step.TransactOpts)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_Ownable2Step *Ownable2StepTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
+	return _Ownable2Step.contract.Transact(opts, "transferOwnership", newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_Ownable2Step *Ownable2StepSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _Ownable2Step.Contract.TransferOwnership(&_Ownable2Step.TransactOpts, newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_Ownable2Step *Ownable2StepTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _Ownable2Step.Contract.TransferOwnership(&_Ownable2Step.TransactOpts, newOwner)
+}
+
+// Ownable2StepOwnershipTransferStartedIterator is returned from FilterOwnershipTransferStarted and is used to iterate over the raw logs and unpacked data for OwnershipTransferStarted events raised by the Ownable2Step contract.
+type Ownable2StepOwnershipTransferStartedIterator struct {
+	Event *Ownable2StepOwnershipTransferStarted // 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 *Ownable2StepOwnershipTransferStartedIterator) 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(Ownable2StepOwnershipTransferStarted)
+			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(Ownable2StepOwnershipTransferStarted)
+		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 *Ownable2StepOwnershipTransferStartedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *Ownable2StepOwnershipTransferStartedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// Ownable2StepOwnershipTransferStarted represents a OwnershipTransferStarted event raised by the Ownable2Step contract.
+type Ownable2StepOwnershipTransferStarted struct {
+	PreviousOwner common.Address
+	NewOwner      common.Address
+	Raw           types.Log // Blockchain specific contextual infos
+}
+
+// FilterOwnershipTransferStarted is a free log retrieval operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_Ownable2Step *Ownable2StepFilterer) FilterOwnershipTransferStarted(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*Ownable2StepOwnershipTransferStartedIterator, 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 := _Ownable2Step.contract.FilterLogs(opts, "OwnershipTransferStarted", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return &Ownable2StepOwnershipTransferStartedIterator{contract: _Ownable2Step.contract, event: "OwnershipTransferStarted", logs: logs, sub: sub}, nil
+}
+
+// WatchOwnershipTransferStarted is a free log subscription operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_Ownable2Step *Ownable2StepFilterer) WatchOwnershipTransferStarted(opts *bind.WatchOpts, sink chan<- *Ownable2StepOwnershipTransferStarted, 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 := _Ownable2Step.contract.WatchLogs(opts, "OwnershipTransferStarted", 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(Ownable2StepOwnershipTransferStarted)
+				if err := _Ownable2Step.contract.UnpackLog(event, "OwnershipTransferStarted", 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
+}
+
+// ParseOwnershipTransferStarted is a log parse operation binding the contract event 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700.
+//
+// Solidity: event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner)
+func (_Ownable2Step *Ownable2StepFilterer) ParseOwnershipTransferStarted(log types.Log) (*Ownable2StepOwnershipTransferStarted, error) {
+	event := new(Ownable2StepOwnershipTransferStarted)
+	if err := _Ownable2Step.contract.UnpackLog(event, "OwnershipTransferStarted", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// Ownable2StepOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Ownable2Step contract.
+type Ownable2StepOwnershipTransferredIterator struct {
+	Event *Ownable2StepOwnershipTransferred // 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 *Ownable2StepOwnershipTransferredIterator) 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(Ownable2StepOwnershipTransferred)
+			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(Ownable2StepOwnershipTransferred)
+		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 *Ownable2StepOwnershipTransferredIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *Ownable2StepOwnershipTransferredIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// Ownable2StepOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable2Step contract.
+type Ownable2StepOwnershipTransferred 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 (_Ownable2Step *Ownable2StepFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*Ownable2StepOwnershipTransferredIterator, 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 := _Ownable2Step.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return &Ownable2StepOwnershipTransferredIterator{contract: _Ownable2Step.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 (_Ownable2Step *Ownable2StepFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *Ownable2StepOwnershipTransferred, 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 := _Ownable2Step.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(Ownable2StepOwnershipTransferred)
+				if err := _Ownable2Step.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 (_Ownable2Step *Ownable2StepFilterer) ParseOwnershipTransferred(log types.Log) (*Ownable2StepOwnershipTransferred, error) {
+	event := new(Ownable2StepOwnershipTransferred)
+	if err := _Ownable2Step.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// P256VerifierMetaData contains all meta data concerning the P256Verifier contract.
+var P256VerifierMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"P256_VERIFIER\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+}
+
+// P256VerifierABI is the input ABI used to generate the binding from.
+// Deprecated: Use P256VerifierMetaData.ABI instead.
+var P256VerifierABI = P256VerifierMetaData.ABI
+
+// P256Verifier is an auto generated Go binding around an Ethereum contract.
+type P256Verifier struct {
+	P256VerifierCaller     // Read-only binding to the contract
+	P256VerifierTransactor // Write-only binding to the contract
+	P256VerifierFilterer   // Log filterer for contract events
+}
+
+// P256VerifierCaller is an auto generated read-only Go binding around an Ethereum contract.
+type P256VerifierCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// P256VerifierTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type P256VerifierTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// P256VerifierFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type P256VerifierFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// P256VerifierSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type P256VerifierSession struct {
+	Contract     *P256Verifier     // 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
+}
+
+// P256VerifierCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type P256VerifierCallerSession struct {
+	Contract *P256VerifierCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts       // Call options to use throughout this session
+}
+
+// P256VerifierTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type P256VerifierTransactorSession struct {
+	Contract     *P256VerifierTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
+}
+
+// P256VerifierRaw is an auto generated low-level Go binding around an Ethereum contract.
+type P256VerifierRaw struct {
+	Contract *P256Verifier // Generic contract binding to access the raw methods on
+}
+
+// P256VerifierCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type P256VerifierCallerRaw struct {
+	Contract *P256VerifierCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// P256VerifierTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type P256VerifierTransactorRaw struct {
+	Contract *P256VerifierTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewP256Verifier creates a new instance of P256Verifier, bound to a specific deployed contract.
+func NewP256Verifier(address common.Address, backend bind.ContractBackend) (*P256Verifier, error) {
+	contract, err := bindP256Verifier(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &P256Verifier{P256VerifierCaller: P256VerifierCaller{contract: contract}, P256VerifierTransactor: P256VerifierTransactor{contract: contract}, P256VerifierFilterer: P256VerifierFilterer{contract: contract}}, nil
+}
+
+// NewP256VerifierCaller creates a new read-only instance of P256Verifier, bound to a specific deployed contract.
+func NewP256VerifierCaller(address common.Address, caller bind.ContractCaller) (*P256VerifierCaller, error) {
+	contract, err := bindP256Verifier(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &P256VerifierCaller{contract: contract}, nil
+}
+
+// NewP256VerifierTransactor creates a new write-only instance of P256Verifier, bound to a specific deployed contract.
+func NewP256VerifierTransactor(address common.Address, transactor bind.ContractTransactor) (*P256VerifierTransactor, error) {
+	contract, err := bindP256Verifier(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &P256VerifierTransactor{contract: contract}, nil
+}
+
+// NewP256VerifierFilterer creates a new log filterer instance of P256Verifier, bound to a specific deployed contract.
+func NewP256VerifierFilterer(address common.Address, filterer bind.ContractFilterer) (*P256VerifierFilterer, error) {
+	contract, err := bindP256Verifier(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &P256VerifierFilterer{contract: contract}, nil
+}
+
+// bindP256Verifier binds a generic wrapper to an already deployed contract.
+func bindP256Verifier(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := P256VerifierMetaData.GetAbi()
+	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 (_P256Verifier *P256VerifierRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _P256Verifier.Contract.P256VerifierCaller.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 (_P256Verifier *P256VerifierRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _P256Verifier.Contract.P256VerifierTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_P256Verifier *P256VerifierRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _P256Verifier.Contract.P256VerifierTransactor.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 (_P256Verifier *P256VerifierCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _P256Verifier.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 (_P256Verifier *P256VerifierTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _P256Verifier.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_P256Verifier *P256VerifierTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _P256Verifier.Contract.contract.Transact(opts, method, params...)
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_P256Verifier *P256VerifierCaller) P256VERIFIER(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _P256Verifier.contract.Call(opts, &out, "P256_VERIFIER")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_P256Verifier *P256VerifierSession) P256VERIFIER() (common.Address, error) {
+	return _P256Verifier.Contract.P256VERIFIER(&_P256Verifier.CallOpts)
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_P256Verifier *P256VerifierCallerSession) P256VERIFIER() (common.Address, error) {
+	return _P256Verifier.Contract.P256VERIFIER(&_P256Verifier.CallOpts)
+}
+
+// PCKHelperMetaData contains all meta data concerning the PCKHelper contract.
+var PCKHelperMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"certIsNotExpired\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isValid\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getIssuerCommonName\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"issuerCommonName\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getSerialNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"serialNum\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getSubjectCommonName\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"subjectCommonName\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getSubjectPublicKey\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"pubKey\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getTbsAndSig\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"tbs\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"sig\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"extensionPtr\",\"type\":\"uint256\"}],\"name\":\"parsePckExtension\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"pcesvn\",\"type\":\"uint16\"},{\"internalType\":\"uint8[]\",\"name\":\"cpusvns\",\"type\":\"uint8[]\"},{\"internalType\":\"bytes\",\"name\":\"fmspcBytes\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"pceidBytes\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"parseX509DER\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"serialNumber\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"issuerCommonName\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"validityNotBefore\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"validityNotAfter\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"subjectCommonName\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"subjectPublicKey\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"extensionPtr\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"tbs\",\"type\":\"bytes\"}],\"internalType\":\"structX509CertObj\",\"name\":\"cert\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
+	Bin: "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",
+}
+
+// PCKHelperABI is the input ABI used to generate the binding from.
+// Deprecated: Use PCKHelperMetaData.ABI instead.
+var PCKHelperABI = PCKHelperMetaData.ABI
+
+// PCKHelperBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use PCKHelperMetaData.Bin instead.
+var PCKHelperBin = PCKHelperMetaData.Bin
+
+// DeployPCKHelper deploys a new Ethereum contract, binding an instance of PCKHelper to it.
+func DeployPCKHelper(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *PCKHelper, error) {
+	parsed, err := PCKHelperMetaData.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(PCKHelperBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &PCKHelper{PCKHelperCaller: PCKHelperCaller{contract: contract}, PCKHelperTransactor: PCKHelperTransactor{contract: contract}, PCKHelperFilterer: PCKHelperFilterer{contract: contract}}, nil
+}
+
+// PCKHelper is an auto generated Go binding around an Ethereum contract.
+type PCKHelper struct {
+	PCKHelperCaller     // Read-only binding to the contract
+	PCKHelperTransactor // Write-only binding to the contract
+	PCKHelperFilterer   // Log filterer for contract events
+}
+
+// PCKHelperCaller is an auto generated read-only Go binding around an Ethereum contract.
+type PCKHelperCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// PCKHelperTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type PCKHelperTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// PCKHelperFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type PCKHelperFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// PCKHelperSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type PCKHelperSession struct {
+	Contract     *PCKHelper        // 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
+}
+
+// PCKHelperCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type PCKHelperCallerSession struct {
+	Contract *PCKHelperCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts    // Call options to use throughout this session
+}
+
+// PCKHelperTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type PCKHelperTransactorSession struct {
+	Contract     *PCKHelperTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
+}
+
+// PCKHelperRaw is an auto generated low-level Go binding around an Ethereum contract.
+type PCKHelperRaw struct {
+	Contract *PCKHelper // Generic contract binding to access the raw methods on
+}
+
+// PCKHelperCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type PCKHelperCallerRaw struct {
+	Contract *PCKHelperCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// PCKHelperTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type PCKHelperTransactorRaw struct {
+	Contract *PCKHelperTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewPCKHelper creates a new instance of PCKHelper, bound to a specific deployed contract.
+func NewPCKHelper(address common.Address, backend bind.ContractBackend) (*PCKHelper, error) {
+	contract, err := bindPCKHelper(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &PCKHelper{PCKHelperCaller: PCKHelperCaller{contract: contract}, PCKHelperTransactor: PCKHelperTransactor{contract: contract}, PCKHelperFilterer: PCKHelperFilterer{contract: contract}}, nil
+}
+
+// NewPCKHelperCaller creates a new read-only instance of PCKHelper, bound to a specific deployed contract.
+func NewPCKHelperCaller(address common.Address, caller bind.ContractCaller) (*PCKHelperCaller, error) {
+	contract, err := bindPCKHelper(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &PCKHelperCaller{contract: contract}, nil
+}
+
+// NewPCKHelperTransactor creates a new write-only instance of PCKHelper, bound to a specific deployed contract.
+func NewPCKHelperTransactor(address common.Address, transactor bind.ContractTransactor) (*PCKHelperTransactor, error) {
+	contract, err := bindPCKHelper(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &PCKHelperTransactor{contract: contract}, nil
+}
+
+// NewPCKHelperFilterer creates a new log filterer instance of PCKHelper, bound to a specific deployed contract.
+func NewPCKHelperFilterer(address common.Address, filterer bind.ContractFilterer) (*PCKHelperFilterer, error) {
+	contract, err := bindPCKHelper(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &PCKHelperFilterer{contract: contract}, nil
+}
+
+// bindPCKHelper binds a generic wrapper to an already deployed contract.
+func bindPCKHelper(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := PCKHelperMetaData.GetAbi()
+	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 (_PCKHelper *PCKHelperRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _PCKHelper.Contract.PCKHelperCaller.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 (_PCKHelper *PCKHelperRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _PCKHelper.Contract.PCKHelperTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_PCKHelper *PCKHelperRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _PCKHelper.Contract.PCKHelperTransactor.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 (_PCKHelper *PCKHelperCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _PCKHelper.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 (_PCKHelper *PCKHelperTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _PCKHelper.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_PCKHelper *PCKHelperTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _PCKHelper.Contract.contract.Transact(opts, method, params...)
+}
+
+// CertIsNotExpired is a free data retrieval call binding the contract method 0xed333785.
+//
+// Solidity: function certIsNotExpired(bytes der) view returns(bool isValid)
+func (_PCKHelper *PCKHelperCaller) CertIsNotExpired(opts *bind.CallOpts, der []byte) (bool, error) {
+	var out []interface{}
+	err := _PCKHelper.contract.Call(opts, &out, "certIsNotExpired", der)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// CertIsNotExpired is a free data retrieval call binding the contract method 0xed333785.
+//
+// Solidity: function certIsNotExpired(bytes der) view returns(bool isValid)
+func (_PCKHelper *PCKHelperSession) CertIsNotExpired(der []byte) (bool, error) {
+	return _PCKHelper.Contract.CertIsNotExpired(&_PCKHelper.CallOpts, der)
+}
+
+// CertIsNotExpired is a free data retrieval call binding the contract method 0xed333785.
+//
+// Solidity: function certIsNotExpired(bytes der) view returns(bool isValid)
+func (_PCKHelper *PCKHelperCallerSession) CertIsNotExpired(der []byte) (bool, error) {
+	return _PCKHelper.Contract.CertIsNotExpired(&_PCKHelper.CallOpts, der)
+}
+
+// GetIssuerCommonName is a free data retrieval call binding the contract method 0x634fdad5.
+//
+// Solidity: function getIssuerCommonName(bytes der) pure returns(string issuerCommonName)
+func (_PCKHelper *PCKHelperCaller) GetIssuerCommonName(opts *bind.CallOpts, der []byte) (string, error) {
+	var out []interface{}
+	err := _PCKHelper.contract.Call(opts, &out, "getIssuerCommonName", der)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetIssuerCommonName is a free data retrieval call binding the contract method 0x634fdad5.
+//
+// Solidity: function getIssuerCommonName(bytes der) pure returns(string issuerCommonName)
+func (_PCKHelper *PCKHelperSession) GetIssuerCommonName(der []byte) (string, error) {
+	return _PCKHelper.Contract.GetIssuerCommonName(&_PCKHelper.CallOpts, der)
+}
+
+// GetIssuerCommonName is a free data retrieval call binding the contract method 0x634fdad5.
+//
+// Solidity: function getIssuerCommonName(bytes der) pure returns(string issuerCommonName)
+func (_PCKHelper *PCKHelperCallerSession) GetIssuerCommonName(der []byte) (string, error) {
+	return _PCKHelper.Contract.GetIssuerCommonName(&_PCKHelper.CallOpts, der)
+}
+
+// GetSerialNumber is a free data retrieval call binding the contract method 0xb29b51cb.
+//
+// Solidity: function getSerialNumber(bytes der) pure returns(uint256 serialNum)
+func (_PCKHelper *PCKHelperCaller) GetSerialNumber(opts *bind.CallOpts, der []byte) (*big.Int, error) {
+	var out []interface{}
+	err := _PCKHelper.contract.Call(opts, &out, "getSerialNumber", der)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetSerialNumber is a free data retrieval call binding the contract method 0xb29b51cb.
+//
+// Solidity: function getSerialNumber(bytes der) pure returns(uint256 serialNum)
+func (_PCKHelper *PCKHelperSession) GetSerialNumber(der []byte) (*big.Int, error) {
+	return _PCKHelper.Contract.GetSerialNumber(&_PCKHelper.CallOpts, der)
+}
+
+// GetSerialNumber is a free data retrieval call binding the contract method 0xb29b51cb.
+//
+// Solidity: function getSerialNumber(bytes der) pure returns(uint256 serialNum)
+func (_PCKHelper *PCKHelperCallerSession) GetSerialNumber(der []byte) (*big.Int, error) {
+	return _PCKHelper.Contract.GetSerialNumber(&_PCKHelper.CallOpts, der)
+}
+
+// GetSubjectCommonName is a free data retrieval call binding the contract method 0x35c757bd.
+//
+// Solidity: function getSubjectCommonName(bytes der) pure returns(string subjectCommonName)
+func (_PCKHelper *PCKHelperCaller) GetSubjectCommonName(opts *bind.CallOpts, der []byte) (string, error) {
+	var out []interface{}
+	err := _PCKHelper.contract.Call(opts, &out, "getSubjectCommonName", der)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetSubjectCommonName is a free data retrieval call binding the contract method 0x35c757bd.
+//
+// Solidity: function getSubjectCommonName(bytes der) pure returns(string subjectCommonName)
+func (_PCKHelper *PCKHelperSession) GetSubjectCommonName(der []byte) (string, error) {
+	return _PCKHelper.Contract.GetSubjectCommonName(&_PCKHelper.CallOpts, der)
+}
+
+// GetSubjectCommonName is a free data retrieval call binding the contract method 0x35c757bd.
+//
+// Solidity: function getSubjectCommonName(bytes der) pure returns(string subjectCommonName)
+func (_PCKHelper *PCKHelperCallerSession) GetSubjectCommonName(der []byte) (string, error) {
+	return _PCKHelper.Contract.GetSubjectCommonName(&_PCKHelper.CallOpts, der)
+}
+
+// GetSubjectPublicKey is a free data retrieval call binding the contract method 0x6d3537a0.
+//
+// Solidity: function getSubjectPublicKey(bytes der) pure returns(bytes pubKey)
+func (_PCKHelper *PCKHelperCaller) GetSubjectPublicKey(opts *bind.CallOpts, der []byte) ([]byte, error) {
+	var out []interface{}
+	err := _PCKHelper.contract.Call(opts, &out, "getSubjectPublicKey", der)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// GetSubjectPublicKey is a free data retrieval call binding the contract method 0x6d3537a0.
+//
+// Solidity: function getSubjectPublicKey(bytes der) pure returns(bytes pubKey)
+func (_PCKHelper *PCKHelperSession) GetSubjectPublicKey(der []byte) ([]byte, error) {
+	return _PCKHelper.Contract.GetSubjectPublicKey(&_PCKHelper.CallOpts, der)
+}
+
+// GetSubjectPublicKey is a free data retrieval call binding the contract method 0x6d3537a0.
+//
+// Solidity: function getSubjectPublicKey(bytes der) pure returns(bytes pubKey)
+func (_PCKHelper *PCKHelperCallerSession) GetSubjectPublicKey(der []byte) ([]byte, error) {
+	return _PCKHelper.Contract.GetSubjectPublicKey(&_PCKHelper.CallOpts, der)
+}
+
+// GetTbsAndSig is a free data retrieval call binding the contract method 0xfcf0be24.
+//
+// Solidity: function getTbsAndSig(bytes der) pure returns(bytes tbs, bytes sig)
+func (_PCKHelper *PCKHelperCaller) GetTbsAndSig(opts *bind.CallOpts, der []byte) (struct {
+	Tbs []byte
+	Sig []byte
+}, error) {
+	var out []interface{}
+	err := _PCKHelper.contract.Call(opts, &out, "getTbsAndSig", der)
+
+	outstruct := new(struct {
+		Tbs []byte
+		Sig []byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.Tbs = *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+	outstruct.Sig = *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return *outstruct, err
+
+}
+
+// GetTbsAndSig is a free data retrieval call binding the contract method 0xfcf0be24.
+//
+// Solidity: function getTbsAndSig(bytes der) pure returns(bytes tbs, bytes sig)
+func (_PCKHelper *PCKHelperSession) GetTbsAndSig(der []byte) (struct {
+	Tbs []byte
+	Sig []byte
+}, error) {
+	return _PCKHelper.Contract.GetTbsAndSig(&_PCKHelper.CallOpts, der)
+}
+
+// GetTbsAndSig is a free data retrieval call binding the contract method 0xfcf0be24.
+//
+// Solidity: function getTbsAndSig(bytes der) pure returns(bytes tbs, bytes sig)
+func (_PCKHelper *PCKHelperCallerSession) GetTbsAndSig(der []byte) (struct {
+	Tbs []byte
+	Sig []byte
+}, error) {
+	return _PCKHelper.Contract.GetTbsAndSig(&_PCKHelper.CallOpts, der)
+}
+
+// ParsePckExtension is a free data retrieval call binding the contract method 0xe81c707e.
+//
+// Solidity: function parsePckExtension(bytes der, uint256 extensionPtr) pure returns(uint16 pcesvn, uint8[] cpusvns, bytes fmspcBytes, bytes pceidBytes)
+func (_PCKHelper *PCKHelperCaller) ParsePckExtension(opts *bind.CallOpts, der []byte, extensionPtr *big.Int) (struct {
+	Pcesvn     uint16
+	Cpusvns    []uint8
+	FmspcBytes []byte
+	PceidBytes []byte
+}, error) {
+	var out []interface{}
+	err := _PCKHelper.contract.Call(opts, &out, "parsePckExtension", der, extensionPtr)
+
+	outstruct := new(struct {
+		Pcesvn     uint16
+		Cpusvns    []uint8
+		FmspcBytes []byte
+		PceidBytes []byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.Pcesvn = *abi.ConvertType(out[0], new(uint16)).(*uint16)
+	outstruct.Cpusvns = *abi.ConvertType(out[1], new([]uint8)).(*[]uint8)
+	outstruct.FmspcBytes = *abi.ConvertType(out[2], new([]byte)).(*[]byte)
+	outstruct.PceidBytes = *abi.ConvertType(out[3], new([]byte)).(*[]byte)
+
+	return *outstruct, err
+
+}
+
+// ParsePckExtension is a free data retrieval call binding the contract method 0xe81c707e.
+//
+// Solidity: function parsePckExtension(bytes der, uint256 extensionPtr) pure returns(uint16 pcesvn, uint8[] cpusvns, bytes fmspcBytes, bytes pceidBytes)
+func (_PCKHelper *PCKHelperSession) ParsePckExtension(der []byte, extensionPtr *big.Int) (struct {
+	Pcesvn     uint16
+	Cpusvns    []uint8
+	FmspcBytes []byte
+	PceidBytes []byte
+}, error) {
+	return _PCKHelper.Contract.ParsePckExtension(&_PCKHelper.CallOpts, der, extensionPtr)
+}
+
+// ParsePckExtension is a free data retrieval call binding the contract method 0xe81c707e.
+//
+// Solidity: function parsePckExtension(bytes der, uint256 extensionPtr) pure returns(uint16 pcesvn, uint8[] cpusvns, bytes fmspcBytes, bytes pceidBytes)
+func (_PCKHelper *PCKHelperCallerSession) ParsePckExtension(der []byte, extensionPtr *big.Int) (struct {
+	Pcesvn     uint16
+	Cpusvns    []uint8
+	FmspcBytes []byte
+	PceidBytes []byte
+}, error) {
+	return _PCKHelper.Contract.ParsePckExtension(&_PCKHelper.CallOpts, der, extensionPtr)
+}
+
+// ParseX509DER is a free data retrieval call binding the contract method 0x3b79a61e.
+//
+// Solidity: function parseX509DER(bytes der) pure returns((uint256,string,uint256,uint256,string,bytes,uint256,bytes,bytes) cert)
+func (_PCKHelper *PCKHelperCaller) ParseX509DER(opts *bind.CallOpts, der []byte) (X509CertObj, error) {
+	var out []interface{}
+	err := _PCKHelper.contract.Call(opts, &out, "parseX509DER", der)
+
+	if err != nil {
+		return *new(X509CertObj), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(X509CertObj)).(*X509CertObj)
+
+	return out0, err
+
+}
+
+// ParseX509DER is a free data retrieval call binding the contract method 0x3b79a61e.
+//
+// Solidity: function parseX509DER(bytes der) pure returns((uint256,string,uint256,uint256,string,bytes,uint256,bytes,bytes) cert)
+func (_PCKHelper *PCKHelperSession) ParseX509DER(der []byte) (X509CertObj, error) {
+	return _PCKHelper.Contract.ParseX509DER(&_PCKHelper.CallOpts, der)
+}
+
+// ParseX509DER is a free data retrieval call binding the contract method 0x3b79a61e.
+//
+// Solidity: function parseX509DER(bytes der) pure returns((uint256,string,uint256,uint256,string,bytes,uint256,bytes,bytes) cert)
+func (_PCKHelper *PCKHelperCallerSession) ParseX509DER(der []byte) (X509CertObj, error) {
+	return _PCKHelper.Contract.ParseX509DER(&_PCKHelper.CallOpts, der)
+}
+
+// PcsDaoMetaData contains all meta data concerning the PcsDao contract.
+var PcsDaoMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"P256_VERIFIER\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumCA\",\"name\":\"ca\",\"type\":\"uint8\"},{\"internalType\":\"bool\",\"name\":\"isCrl\",\"type\":\"bool\"}],\"name\":\"PCS_KEY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"crlLib\",\"outputs\":[{\"internalType\":\"contractX509CRLHelper\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"}],\"name\":\"getAttestedData\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"attestationData\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumCA\",\"name\":\"ca\",\"type\":\"uint8\"}],\"name\":\"getCertificateById\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"cert\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"crl\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"}],\"name\":\"getCollateralHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"collateralHash\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resolver\",\"outputs\":[{\"internalType\":\"contractIDaoAttestationResolver\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumCA\",\"name\":\"ca\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"crl\",\"type\":\"bytes\"}],\"name\":\"upsertPckCrl\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"attestationId\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumCA\",\"name\":\"ca\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"cert\",\"type\":\"bytes\"}],\"name\":\"upsertPcsCertificates\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"attestationId\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"rootcacrl\",\"type\":\"bytes\"}],\"name\":\"upsertRootCACrl\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"attestationId\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"x509\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"Certificate_Expired\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"enumCA\",\"name\":\"ca\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"serialNum\",\"type\":\"uint256\"}],\"name\":\"Certificate_Revoked\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Expired_Certificates\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Invalid_Issuer_Name\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"enumCA\",\"name\":\"ca\",\"type\":\"uint8\"}],\"name\":\"Invalid_PCK_CA\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Invalid_Signature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Invalid_Subject_Name\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"enumCA\",\"name\":\"ca\",\"type\":\"uint8\"}],\"name\":\"Missing_Certificate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Missing_Issuer\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Root_Key_Mismatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TCB_Mismatch\",\"type\":\"error\"}]",
+}
+
+// PcsDaoABI is the input ABI used to generate the binding from.
+// Deprecated: Use PcsDaoMetaData.ABI instead.
+var PcsDaoABI = PcsDaoMetaData.ABI
+
+// PcsDao is an auto generated Go binding around an Ethereum contract.
+type PcsDao struct {
+	PcsDaoCaller     // Read-only binding to the contract
+	PcsDaoTransactor // Write-only binding to the contract
+	PcsDaoFilterer   // Log filterer for contract events
+}
+
+// PcsDaoCaller is an auto generated read-only Go binding around an Ethereum contract.
+type PcsDaoCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// PcsDaoTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type PcsDaoTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// PcsDaoFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type PcsDaoFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// PcsDaoSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type PcsDaoSession struct {
+	Contract     *PcsDao           // 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
+}
+
+// PcsDaoCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type PcsDaoCallerSession struct {
+	Contract *PcsDaoCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts // Call options to use throughout this session
+}
+
+// PcsDaoTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type PcsDaoTransactorSession struct {
+	Contract     *PcsDaoTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// PcsDaoRaw is an auto generated low-level Go binding around an Ethereum contract.
+type PcsDaoRaw struct {
+	Contract *PcsDao // Generic contract binding to access the raw methods on
+}
+
+// PcsDaoCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type PcsDaoCallerRaw struct {
+	Contract *PcsDaoCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// PcsDaoTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type PcsDaoTransactorRaw struct {
+	Contract *PcsDaoTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewPcsDao creates a new instance of PcsDao, bound to a specific deployed contract.
+func NewPcsDao(address common.Address, backend bind.ContractBackend) (*PcsDao, error) {
+	contract, err := bindPcsDao(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &PcsDao{PcsDaoCaller: PcsDaoCaller{contract: contract}, PcsDaoTransactor: PcsDaoTransactor{contract: contract}, PcsDaoFilterer: PcsDaoFilterer{contract: contract}}, nil
+}
+
+// NewPcsDaoCaller creates a new read-only instance of PcsDao, bound to a specific deployed contract.
+func NewPcsDaoCaller(address common.Address, caller bind.ContractCaller) (*PcsDaoCaller, error) {
+	contract, err := bindPcsDao(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &PcsDaoCaller{contract: contract}, nil
+}
+
+// NewPcsDaoTransactor creates a new write-only instance of PcsDao, bound to a specific deployed contract.
+func NewPcsDaoTransactor(address common.Address, transactor bind.ContractTransactor) (*PcsDaoTransactor, error) {
+	contract, err := bindPcsDao(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &PcsDaoTransactor{contract: contract}, nil
+}
+
+// NewPcsDaoFilterer creates a new log filterer instance of PcsDao, bound to a specific deployed contract.
+func NewPcsDaoFilterer(address common.Address, filterer bind.ContractFilterer) (*PcsDaoFilterer, error) {
+	contract, err := bindPcsDao(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &PcsDaoFilterer{contract: contract}, nil
+}
+
+// bindPcsDao binds a generic wrapper to an already deployed contract.
+func bindPcsDao(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := PcsDaoMetaData.GetAbi()
+	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 (_PcsDao *PcsDaoRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _PcsDao.Contract.PcsDaoCaller.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 (_PcsDao *PcsDaoRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _PcsDao.Contract.PcsDaoTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_PcsDao *PcsDaoRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _PcsDao.Contract.PcsDaoTransactor.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 (_PcsDao *PcsDaoCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _PcsDao.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 (_PcsDao *PcsDaoTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _PcsDao.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_PcsDao *PcsDaoTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _PcsDao.Contract.contract.Transact(opts, method, params...)
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_PcsDao *PcsDaoCaller) P256VERIFIER(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _PcsDao.contract.Call(opts, &out, "P256_VERIFIER")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_PcsDao *PcsDaoSession) P256VERIFIER() (common.Address, error) {
+	return _PcsDao.Contract.P256VERIFIER(&_PcsDao.CallOpts)
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_PcsDao *PcsDaoCallerSession) P256VERIFIER() (common.Address, error) {
+	return _PcsDao.Contract.P256VERIFIER(&_PcsDao.CallOpts)
+}
+
+// PCSKEY is a free data retrieval call binding the contract method 0xb13bf290.
+//
+// Solidity: function PCS_KEY(uint8 ca, bool isCrl) pure returns(bytes32 key)
+func (_PcsDao *PcsDaoCaller) PCSKEY(opts *bind.CallOpts, ca uint8, isCrl bool) ([32]byte, error) {
+	var out []interface{}
+	err := _PcsDao.contract.Call(opts, &out, "PCS_KEY", ca, isCrl)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// PCSKEY is a free data retrieval call binding the contract method 0xb13bf290.
+//
+// Solidity: function PCS_KEY(uint8 ca, bool isCrl) pure returns(bytes32 key)
+func (_PcsDao *PcsDaoSession) PCSKEY(ca uint8, isCrl bool) ([32]byte, error) {
+	return _PcsDao.Contract.PCSKEY(&_PcsDao.CallOpts, ca, isCrl)
+}
+
+// PCSKEY is a free data retrieval call binding the contract method 0xb13bf290.
+//
+// Solidity: function PCS_KEY(uint8 ca, bool isCrl) pure returns(bytes32 key)
+func (_PcsDao *PcsDaoCallerSession) PCSKEY(ca uint8, isCrl bool) ([32]byte, error) {
+	return _PcsDao.Contract.PCSKEY(&_PcsDao.CallOpts, ca, isCrl)
+}
+
+// CrlLib is a free data retrieval call binding the contract method 0x37b8762d.
+//
+// Solidity: function crlLib() view returns(address)
+func (_PcsDao *PcsDaoCaller) CrlLib(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _PcsDao.contract.Call(opts, &out, "crlLib")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// CrlLib is a free data retrieval call binding the contract method 0x37b8762d.
+//
+// Solidity: function crlLib() view returns(address)
+func (_PcsDao *PcsDaoSession) CrlLib() (common.Address, error) {
+	return _PcsDao.Contract.CrlLib(&_PcsDao.CallOpts)
+}
+
+// CrlLib is a free data retrieval call binding the contract method 0x37b8762d.
+//
+// Solidity: function crlLib() view returns(address)
+func (_PcsDao *PcsDaoCallerSession) CrlLib() (common.Address, error) {
+	return _PcsDao.Contract.CrlLib(&_PcsDao.CallOpts)
+}
+
+// GetAttestedData is a free data retrieval call binding the contract method 0xb414d0b2.
+//
+// Solidity: function getAttestedData(bytes32 key) view returns(bytes attestationData)
+func (_PcsDao *PcsDaoCaller) GetAttestedData(opts *bind.CallOpts, key [32]byte) ([]byte, error) {
+	var out []interface{}
+	err := _PcsDao.contract.Call(opts, &out, "getAttestedData", key)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// GetAttestedData is a free data retrieval call binding the contract method 0xb414d0b2.
+//
+// Solidity: function getAttestedData(bytes32 key) view returns(bytes attestationData)
+func (_PcsDao *PcsDaoSession) GetAttestedData(key [32]byte) ([]byte, error) {
+	return _PcsDao.Contract.GetAttestedData(&_PcsDao.CallOpts, key)
+}
+
+// GetAttestedData is a free data retrieval call binding the contract method 0xb414d0b2.
+//
+// Solidity: function getAttestedData(bytes32 key) view returns(bytes attestationData)
+func (_PcsDao *PcsDaoCallerSession) GetAttestedData(key [32]byte) ([]byte, error) {
+	return _PcsDao.Contract.GetAttestedData(&_PcsDao.CallOpts, key)
+}
+
+// GetCertificateById is a free data retrieval call binding the contract method 0x722f1327.
+//
+// Solidity: function getCertificateById(uint8 ca) view returns(bytes cert, bytes crl)
+func (_PcsDao *PcsDaoCaller) GetCertificateById(opts *bind.CallOpts, ca uint8) (struct {
+	Cert []byte
+	Crl  []byte
+}, error) {
+	var out []interface{}
+	err := _PcsDao.contract.Call(opts, &out, "getCertificateById", ca)
+
+	outstruct := new(struct {
+		Cert []byte
+		Crl  []byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.Cert = *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+	outstruct.Crl = *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return *outstruct, err
+
+}
+
+// GetCertificateById is a free data retrieval call binding the contract method 0x722f1327.
+//
+// Solidity: function getCertificateById(uint8 ca) view returns(bytes cert, bytes crl)
+func (_PcsDao *PcsDaoSession) GetCertificateById(ca uint8) (struct {
+	Cert []byte
+	Crl  []byte
+}, error) {
+	return _PcsDao.Contract.GetCertificateById(&_PcsDao.CallOpts, ca)
+}
+
+// GetCertificateById is a free data retrieval call binding the contract method 0x722f1327.
+//
+// Solidity: function getCertificateById(uint8 ca) view returns(bytes cert, bytes crl)
+func (_PcsDao *PcsDaoCallerSession) GetCertificateById(ca uint8) (struct {
+	Cert []byte
+	Crl  []byte
+}, error) {
+	return _PcsDao.Contract.GetCertificateById(&_PcsDao.CallOpts, ca)
+}
+
+// GetCollateralHash is a free data retrieval call binding the contract method 0xbf721aaf.
+//
+// Solidity: function getCollateralHash(bytes32 key) view returns(bytes32 collateralHash)
+func (_PcsDao *PcsDaoCaller) GetCollateralHash(opts *bind.CallOpts, key [32]byte) ([32]byte, error) {
+	var out []interface{}
+	err := _PcsDao.contract.Call(opts, &out, "getCollateralHash", key)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// GetCollateralHash is a free data retrieval call binding the contract method 0xbf721aaf.
+//
+// Solidity: function getCollateralHash(bytes32 key) view returns(bytes32 collateralHash)
+func (_PcsDao *PcsDaoSession) GetCollateralHash(key [32]byte) ([32]byte, error) {
+	return _PcsDao.Contract.GetCollateralHash(&_PcsDao.CallOpts, key)
+}
+
+// GetCollateralHash is a free data retrieval call binding the contract method 0xbf721aaf.
+//
+// Solidity: function getCollateralHash(bytes32 key) view returns(bytes32 collateralHash)
+func (_PcsDao *PcsDaoCallerSession) GetCollateralHash(key [32]byte) ([32]byte, error) {
+	return _PcsDao.Contract.GetCollateralHash(&_PcsDao.CallOpts, key)
+}
+
+// Resolver is a free data retrieval call binding the contract method 0x04f3bcec.
+//
+// Solidity: function resolver() view returns(address)
+func (_PcsDao *PcsDaoCaller) Resolver(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _PcsDao.contract.Call(opts, &out, "resolver")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// Resolver is a free data retrieval call binding the contract method 0x04f3bcec.
+//
+// Solidity: function resolver() view returns(address)
+func (_PcsDao *PcsDaoSession) Resolver() (common.Address, error) {
+	return _PcsDao.Contract.Resolver(&_PcsDao.CallOpts)
+}
+
+// Resolver is a free data retrieval call binding the contract method 0x04f3bcec.
+//
+// Solidity: function resolver() view returns(address)
+func (_PcsDao *PcsDaoCallerSession) Resolver() (common.Address, error) {
+	return _PcsDao.Contract.Resolver(&_PcsDao.CallOpts)
+}
+
+// X509 is a free data retrieval call binding the contract method 0xec950d33.
+//
+// Solidity: function x509() view returns(address)
+func (_PcsDao *PcsDaoCaller) X509(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _PcsDao.contract.Call(opts, &out, "x509")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// X509 is a free data retrieval call binding the contract method 0xec950d33.
+//
+// Solidity: function x509() view returns(address)
+func (_PcsDao *PcsDaoSession) X509() (common.Address, error) {
+	return _PcsDao.Contract.X509(&_PcsDao.CallOpts)
+}
+
+// X509 is a free data retrieval call binding the contract method 0xec950d33.
+//
+// Solidity: function x509() view returns(address)
+func (_PcsDao *PcsDaoCallerSession) X509() (common.Address, error) {
+	return _PcsDao.Contract.X509(&_PcsDao.CallOpts)
+}
+
+// UpsertPckCrl is a paid mutator transaction binding the contract method 0x08854e04.
+//
+// Solidity: function upsertPckCrl(uint8 ca, bytes crl) returns(bytes32 attestationId)
+func (_PcsDao *PcsDaoTransactor) UpsertPckCrl(opts *bind.TransactOpts, ca uint8, crl []byte) (*types.Transaction, error) {
+	return _PcsDao.contract.Transact(opts, "upsertPckCrl", ca, crl)
+}
+
+// UpsertPckCrl is a paid mutator transaction binding the contract method 0x08854e04.
+//
+// Solidity: function upsertPckCrl(uint8 ca, bytes crl) returns(bytes32 attestationId)
+func (_PcsDao *PcsDaoSession) UpsertPckCrl(ca uint8, crl []byte) (*types.Transaction, error) {
+	return _PcsDao.Contract.UpsertPckCrl(&_PcsDao.TransactOpts, ca, crl)
+}
+
+// UpsertPckCrl is a paid mutator transaction binding the contract method 0x08854e04.
+//
+// Solidity: function upsertPckCrl(uint8 ca, bytes crl) returns(bytes32 attestationId)
+func (_PcsDao *PcsDaoTransactorSession) UpsertPckCrl(ca uint8, crl []byte) (*types.Transaction, error) {
+	return _PcsDao.Contract.UpsertPckCrl(&_PcsDao.TransactOpts, ca, crl)
+}
+
+// UpsertPcsCertificates is a paid mutator transaction binding the contract method 0x3b395455.
+//
+// Solidity: function upsertPcsCertificates(uint8 ca, bytes cert) returns(bytes32 attestationId)
+func (_PcsDao *PcsDaoTransactor) UpsertPcsCertificates(opts *bind.TransactOpts, ca uint8, cert []byte) (*types.Transaction, error) {
+	return _PcsDao.contract.Transact(opts, "upsertPcsCertificates", ca, cert)
+}
+
+// UpsertPcsCertificates is a paid mutator transaction binding the contract method 0x3b395455.
+//
+// Solidity: function upsertPcsCertificates(uint8 ca, bytes cert) returns(bytes32 attestationId)
+func (_PcsDao *PcsDaoSession) UpsertPcsCertificates(ca uint8, cert []byte) (*types.Transaction, error) {
+	return _PcsDao.Contract.UpsertPcsCertificates(&_PcsDao.TransactOpts, ca, cert)
+}
+
+// UpsertPcsCertificates is a paid mutator transaction binding the contract method 0x3b395455.
+//
+// Solidity: function upsertPcsCertificates(uint8 ca, bytes cert) returns(bytes32 attestationId)
+func (_PcsDao *PcsDaoTransactorSession) UpsertPcsCertificates(ca uint8, cert []byte) (*types.Transaction, error) {
+	return _PcsDao.Contract.UpsertPcsCertificates(&_PcsDao.TransactOpts, ca, cert)
+}
+
+// UpsertRootCACrl is a paid mutator transaction binding the contract method 0x6b1c5399.
+//
+// Solidity: function upsertRootCACrl(bytes rootcacrl) returns(bytes32 attestationId)
+func (_PcsDao *PcsDaoTransactor) UpsertRootCACrl(opts *bind.TransactOpts, rootcacrl []byte) (*types.Transaction, error) {
+	return _PcsDao.contract.Transact(opts, "upsertRootCACrl", rootcacrl)
+}
+
+// UpsertRootCACrl is a paid mutator transaction binding the contract method 0x6b1c5399.
+//
+// Solidity: function upsertRootCACrl(bytes rootcacrl) returns(bytes32 attestationId)
+func (_PcsDao *PcsDaoSession) UpsertRootCACrl(rootcacrl []byte) (*types.Transaction, error) {
+	return _PcsDao.Contract.UpsertRootCACrl(&_PcsDao.TransactOpts, rootcacrl)
+}
+
+// UpsertRootCACrl is a paid mutator transaction binding the contract method 0x6b1c5399.
+//
+// Solidity: function upsertRootCACrl(bytes rootcacrl) returns(bytes32 attestationId)
+func (_PcsDao *PcsDaoTransactorSession) UpsertRootCACrl(rootcacrl []byte) (*types.Transaction, error) {
+	return _PcsDao.Contract.UpsertRootCACrl(&_PcsDao.TransactOpts, rootcacrl)
+}
+
+// QuoteVerifierBaseMetaData contains all meta data concerning the QuoteVerifierBase contract.
+var QuoteVerifierBaseMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"P256_VERIFIER\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pccsRouter\",\"outputs\":[{\"internalType\":\"contractIPCCSRouter\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"quoteVersion\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint16\",\"name\":\"version\",\"type\":\"uint16\"},{\"internalType\":\"bytes2\",\"name\":\"attestationKeyType\",\"type\":\"bytes2\"},{\"internalType\":\"bytes4\",\"name\":\"teeType\",\"type\":\"bytes4\"},{\"internalType\":\"bytes2\",\"name\":\"qeSvn\",\"type\":\"bytes2\"},{\"internalType\":\"bytes2\",\"name\":\"pceSvn\",\"type\":\"bytes2\"},{\"internalType\":\"bytes16\",\"name\":\"qeVendorId\",\"type\":\"bytes16\"},{\"internalType\":\"bytes20\",\"name\":\"userData\",\"type\":\"bytes20\"}],\"internalType\":\"structHeader\",\"name\":\"\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"verifyQuote\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"verifyZkOutput\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+}
+
+// QuoteVerifierBaseABI is the input ABI used to generate the binding from.
+// Deprecated: Use QuoteVerifierBaseMetaData.ABI instead.
+var QuoteVerifierBaseABI = QuoteVerifierBaseMetaData.ABI
+
+// QuoteVerifierBase is an auto generated Go binding around an Ethereum contract.
+type QuoteVerifierBase struct {
+	QuoteVerifierBaseCaller     // Read-only binding to the contract
+	QuoteVerifierBaseTransactor // Write-only binding to the contract
+	QuoteVerifierBaseFilterer   // Log filterer for contract events
+}
+
+// QuoteVerifierBaseCaller is an auto generated read-only Go binding around an Ethereum contract.
+type QuoteVerifierBaseCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// QuoteVerifierBaseTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type QuoteVerifierBaseTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// QuoteVerifierBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type QuoteVerifierBaseFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// QuoteVerifierBaseSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type QuoteVerifierBaseSession struct {
+	Contract     *QuoteVerifierBase // 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
+}
+
+// QuoteVerifierBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type QuoteVerifierBaseCallerSession struct {
+	Contract *QuoteVerifierBaseCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts            // Call options to use throughout this session
+}
+
+// QuoteVerifierBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type QuoteVerifierBaseTransactorSession struct {
+	Contract     *QuoteVerifierBaseTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts            // Transaction auth options to use throughout this session
+}
+
+// QuoteVerifierBaseRaw is an auto generated low-level Go binding around an Ethereum contract.
+type QuoteVerifierBaseRaw struct {
+	Contract *QuoteVerifierBase // Generic contract binding to access the raw methods on
+}
+
+// QuoteVerifierBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type QuoteVerifierBaseCallerRaw struct {
+	Contract *QuoteVerifierBaseCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// QuoteVerifierBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type QuoteVerifierBaseTransactorRaw struct {
+	Contract *QuoteVerifierBaseTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewQuoteVerifierBase creates a new instance of QuoteVerifierBase, bound to a specific deployed contract.
+func NewQuoteVerifierBase(address common.Address, backend bind.ContractBackend) (*QuoteVerifierBase, error) {
+	contract, err := bindQuoteVerifierBase(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &QuoteVerifierBase{QuoteVerifierBaseCaller: QuoteVerifierBaseCaller{contract: contract}, QuoteVerifierBaseTransactor: QuoteVerifierBaseTransactor{contract: contract}, QuoteVerifierBaseFilterer: QuoteVerifierBaseFilterer{contract: contract}}, nil
+}
+
+// NewQuoteVerifierBaseCaller creates a new read-only instance of QuoteVerifierBase, bound to a specific deployed contract.
+func NewQuoteVerifierBaseCaller(address common.Address, caller bind.ContractCaller) (*QuoteVerifierBaseCaller, error) {
+	contract, err := bindQuoteVerifierBase(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &QuoteVerifierBaseCaller{contract: contract}, nil
+}
+
+// NewQuoteVerifierBaseTransactor creates a new write-only instance of QuoteVerifierBase, bound to a specific deployed contract.
+func NewQuoteVerifierBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*QuoteVerifierBaseTransactor, error) {
+	contract, err := bindQuoteVerifierBase(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &QuoteVerifierBaseTransactor{contract: contract}, nil
+}
+
+// NewQuoteVerifierBaseFilterer creates a new log filterer instance of QuoteVerifierBase, bound to a specific deployed contract.
+func NewQuoteVerifierBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*QuoteVerifierBaseFilterer, error) {
+	contract, err := bindQuoteVerifierBase(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &QuoteVerifierBaseFilterer{contract: contract}, nil
+}
+
+// bindQuoteVerifierBase binds a generic wrapper to an already deployed contract.
+func bindQuoteVerifierBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := QuoteVerifierBaseMetaData.GetAbi()
+	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 (_QuoteVerifierBase *QuoteVerifierBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _QuoteVerifierBase.Contract.QuoteVerifierBaseCaller.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 (_QuoteVerifierBase *QuoteVerifierBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _QuoteVerifierBase.Contract.QuoteVerifierBaseTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_QuoteVerifierBase *QuoteVerifierBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _QuoteVerifierBase.Contract.QuoteVerifierBaseTransactor.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 (_QuoteVerifierBase *QuoteVerifierBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _QuoteVerifierBase.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 (_QuoteVerifierBase *QuoteVerifierBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _QuoteVerifierBase.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_QuoteVerifierBase *QuoteVerifierBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _QuoteVerifierBase.Contract.contract.Transact(opts, method, params...)
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_QuoteVerifierBase *QuoteVerifierBaseCaller) P256VERIFIER(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _QuoteVerifierBase.contract.Call(opts, &out, "P256_VERIFIER")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_QuoteVerifierBase *QuoteVerifierBaseSession) P256VERIFIER() (common.Address, error) {
+	return _QuoteVerifierBase.Contract.P256VERIFIER(&_QuoteVerifierBase.CallOpts)
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_QuoteVerifierBase *QuoteVerifierBaseCallerSession) P256VERIFIER() (common.Address, error) {
+	return _QuoteVerifierBase.Contract.P256VERIFIER(&_QuoteVerifierBase.CallOpts)
+}
+
+// PccsRouter is a free data retrieval call binding the contract method 0x9e0fb0bf.
+//
+// Solidity: function pccsRouter() view returns(address)
+func (_QuoteVerifierBase *QuoteVerifierBaseCaller) PccsRouter(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _QuoteVerifierBase.contract.Call(opts, &out, "pccsRouter")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// PccsRouter is a free data retrieval call binding the contract method 0x9e0fb0bf.
+//
+// Solidity: function pccsRouter() view returns(address)
+func (_QuoteVerifierBase *QuoteVerifierBaseSession) PccsRouter() (common.Address, error) {
+	return _QuoteVerifierBase.Contract.PccsRouter(&_QuoteVerifierBase.CallOpts)
+}
+
+// PccsRouter is a free data retrieval call binding the contract method 0x9e0fb0bf.
+//
+// Solidity: function pccsRouter() view returns(address)
+func (_QuoteVerifierBase *QuoteVerifierBaseCallerSession) PccsRouter() (common.Address, error) {
+	return _QuoteVerifierBase.Contract.PccsRouter(&_QuoteVerifierBase.CallOpts)
+}
+
+// QuoteVersion is a free data retrieval call binding the contract method 0x02077837.
+//
+// Solidity: function quoteVersion() view returns(uint16)
+func (_QuoteVerifierBase *QuoteVerifierBaseCaller) QuoteVersion(opts *bind.CallOpts) (uint16, error) {
+	var out []interface{}
+	err := _QuoteVerifierBase.contract.Call(opts, &out, "quoteVersion")
+
+	if err != nil {
+		return *new(uint16), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint16)).(*uint16)
+
+	return out0, err
+
+}
+
+// QuoteVersion is a free data retrieval call binding the contract method 0x02077837.
+//
+// Solidity: function quoteVersion() view returns(uint16)
+func (_QuoteVerifierBase *QuoteVerifierBaseSession) QuoteVersion() (uint16, error) {
+	return _QuoteVerifierBase.Contract.QuoteVersion(&_QuoteVerifierBase.CallOpts)
+}
+
+// QuoteVersion is a free data retrieval call binding the contract method 0x02077837.
+//
+// Solidity: function quoteVersion() view returns(uint16)
+func (_QuoteVerifierBase *QuoteVerifierBaseCallerSession) QuoteVersion() (uint16, error) {
+	return _QuoteVerifierBase.Contract.QuoteVersion(&_QuoteVerifierBase.CallOpts)
+}
+
+// VerifyQuote is a free data retrieval call binding the contract method 0xf1495114.
+//
+// Solidity: function verifyQuote((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) , bytes ) view returns(bool, bytes)
+func (_QuoteVerifierBase *QuoteVerifierBaseCaller) VerifyQuote(opts *bind.CallOpts, arg0 Header, arg1 []byte) (bool, []byte, error) {
+	var out []interface{}
+	err := _QuoteVerifierBase.contract.Call(opts, &out, "verifyQuote", arg0, arg1)
+
+	if err != nil {
+		return *new(bool), *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+	out1 := *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return out0, out1, err
+
+}
+
+// VerifyQuote is a free data retrieval call binding the contract method 0xf1495114.
+//
+// Solidity: function verifyQuote((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) , bytes ) view returns(bool, bytes)
+func (_QuoteVerifierBase *QuoteVerifierBaseSession) VerifyQuote(arg0 Header, arg1 []byte) (bool, []byte, error) {
+	return _QuoteVerifierBase.Contract.VerifyQuote(&_QuoteVerifierBase.CallOpts, arg0, arg1)
+}
+
+// VerifyQuote is a free data retrieval call binding the contract method 0xf1495114.
+//
+// Solidity: function verifyQuote((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) , bytes ) view returns(bool, bytes)
+func (_QuoteVerifierBase *QuoteVerifierBaseCallerSession) VerifyQuote(arg0 Header, arg1 []byte) (bool, []byte, error) {
+	return _QuoteVerifierBase.Contract.VerifyQuote(&_QuoteVerifierBase.CallOpts, arg0, arg1)
+}
+
+// VerifyZkOutput is a free data retrieval call binding the contract method 0x9ffa5fd9.
+//
+// Solidity: function verifyZkOutput(bytes ) view returns(bool, bytes)
+func (_QuoteVerifierBase *QuoteVerifierBaseCaller) VerifyZkOutput(opts *bind.CallOpts, arg0 []byte) (bool, []byte, error) {
+	var out []interface{}
+	err := _QuoteVerifierBase.contract.Call(opts, &out, "verifyZkOutput", arg0)
+
+	if err != nil {
+		return *new(bool), *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+	out1 := *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return out0, out1, err
+
+}
+
+// VerifyZkOutput is a free data retrieval call binding the contract method 0x9ffa5fd9.
+//
+// Solidity: function verifyZkOutput(bytes ) view returns(bool, bytes)
+func (_QuoteVerifierBase *QuoteVerifierBaseSession) VerifyZkOutput(arg0 []byte) (bool, []byte, error) {
+	return _QuoteVerifierBase.Contract.VerifyZkOutput(&_QuoteVerifierBase.CallOpts, arg0)
+}
+
+// VerifyZkOutput is a free data retrieval call binding the contract method 0x9ffa5fd9.
+//
+// Solidity: function verifyZkOutput(bytes ) view returns(bool, bytes)
+func (_QuoteVerifierBase *QuoteVerifierBaseCallerSession) VerifyZkOutput(arg0 []byte) (bool, []byte, error) {
+	return _QuoteVerifierBase.Contract.VerifyZkOutput(&_QuoteVerifierBase.CallOpts, arg0)
+}
+
+// RedBlackTreeLibMetaData contains all meta data concerning the RedBlackTreeLib contract.
+var RedBlackTreeLibMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"PointerOutOfBounds\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TreeIsFull\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ValueAlreadyExists\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ValueDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ValueIsEmpty\",\"type\":\"error\"}]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220e874e068e236192fac5efd054f6f2833ea4d59fe2f8d60e5660ce82fecbfe5b264736f6c63430008190033",
+}
+
+// RedBlackTreeLibABI is the input ABI used to generate the binding from.
+// Deprecated: Use RedBlackTreeLibMetaData.ABI instead.
+var RedBlackTreeLibABI = RedBlackTreeLibMetaData.ABI
+
+// RedBlackTreeLibBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use RedBlackTreeLibMetaData.Bin instead.
+var RedBlackTreeLibBin = RedBlackTreeLibMetaData.Bin
+
+// DeployRedBlackTreeLib deploys a new Ethereum contract, binding an instance of RedBlackTreeLib to it.
+func DeployRedBlackTreeLib(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *RedBlackTreeLib, error) {
+	parsed, err := RedBlackTreeLibMetaData.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(RedBlackTreeLibBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &RedBlackTreeLib{RedBlackTreeLibCaller: RedBlackTreeLibCaller{contract: contract}, RedBlackTreeLibTransactor: RedBlackTreeLibTransactor{contract: contract}, RedBlackTreeLibFilterer: RedBlackTreeLibFilterer{contract: contract}}, nil
+}
+
+// RedBlackTreeLib is an auto generated Go binding around an Ethereum contract.
+type RedBlackTreeLib struct {
+	RedBlackTreeLibCaller     // Read-only binding to the contract
+	RedBlackTreeLibTransactor // Write-only binding to the contract
+	RedBlackTreeLibFilterer   // Log filterer for contract events
+}
+
+// RedBlackTreeLibCaller is an auto generated read-only Go binding around an Ethereum contract.
+type RedBlackTreeLibCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// RedBlackTreeLibTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type RedBlackTreeLibTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// RedBlackTreeLibFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type RedBlackTreeLibFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// RedBlackTreeLibSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type RedBlackTreeLibSession struct {
+	Contract     *RedBlackTreeLib  // 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
+}
+
+// RedBlackTreeLibCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type RedBlackTreeLibCallerSession struct {
+	Contract *RedBlackTreeLibCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts          // Call options to use throughout this session
+}
+
+// RedBlackTreeLibTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type RedBlackTreeLibTransactorSession struct {
+	Contract     *RedBlackTreeLibTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts          // Transaction auth options to use throughout this session
+}
+
+// RedBlackTreeLibRaw is an auto generated low-level Go binding around an Ethereum contract.
+type RedBlackTreeLibRaw struct {
+	Contract *RedBlackTreeLib // Generic contract binding to access the raw methods on
+}
+
+// RedBlackTreeLibCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type RedBlackTreeLibCallerRaw struct {
+	Contract *RedBlackTreeLibCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// RedBlackTreeLibTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type RedBlackTreeLibTransactorRaw struct {
+	Contract *RedBlackTreeLibTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewRedBlackTreeLib creates a new instance of RedBlackTreeLib, bound to a specific deployed contract.
+func NewRedBlackTreeLib(address common.Address, backend bind.ContractBackend) (*RedBlackTreeLib, error) {
+	contract, err := bindRedBlackTreeLib(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &RedBlackTreeLib{RedBlackTreeLibCaller: RedBlackTreeLibCaller{contract: contract}, RedBlackTreeLibTransactor: RedBlackTreeLibTransactor{contract: contract}, RedBlackTreeLibFilterer: RedBlackTreeLibFilterer{contract: contract}}, nil
+}
+
+// NewRedBlackTreeLibCaller creates a new read-only instance of RedBlackTreeLib, bound to a specific deployed contract.
+func NewRedBlackTreeLibCaller(address common.Address, caller bind.ContractCaller) (*RedBlackTreeLibCaller, error) {
+	contract, err := bindRedBlackTreeLib(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &RedBlackTreeLibCaller{contract: contract}, nil
+}
+
+// NewRedBlackTreeLibTransactor creates a new write-only instance of RedBlackTreeLib, bound to a specific deployed contract.
+func NewRedBlackTreeLibTransactor(address common.Address, transactor bind.ContractTransactor) (*RedBlackTreeLibTransactor, error) {
+	contract, err := bindRedBlackTreeLib(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &RedBlackTreeLibTransactor{contract: contract}, nil
+}
+
+// NewRedBlackTreeLibFilterer creates a new log filterer instance of RedBlackTreeLib, bound to a specific deployed contract.
+func NewRedBlackTreeLibFilterer(address common.Address, filterer bind.ContractFilterer) (*RedBlackTreeLibFilterer, error) {
+	contract, err := bindRedBlackTreeLib(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &RedBlackTreeLibFilterer{contract: contract}, nil
+}
+
+// bindRedBlackTreeLib binds a generic wrapper to an already deployed contract.
+func bindRedBlackTreeLib(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := RedBlackTreeLibMetaData.GetAbi()
+	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 (_RedBlackTreeLib *RedBlackTreeLibRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _RedBlackTreeLib.Contract.RedBlackTreeLibCaller.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 (_RedBlackTreeLib *RedBlackTreeLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _RedBlackTreeLib.Contract.RedBlackTreeLibTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_RedBlackTreeLib *RedBlackTreeLibRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _RedBlackTreeLib.Contract.RedBlackTreeLibTransactor.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 (_RedBlackTreeLib *RedBlackTreeLibCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _RedBlackTreeLib.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 (_RedBlackTreeLib *RedBlackTreeLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _RedBlackTreeLib.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_RedBlackTreeLib *RedBlackTreeLibTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _RedBlackTreeLib.Contract.contract.Transact(opts, method, params...)
+}
+
+// ScriptBaseMetaData contains all meta data concerning the ScriptBase contract.
+var ScriptBaseMetaData = &bind.MetaData{
+	ABI: "[]",
+}
+
+// ScriptBaseABI is the input ABI used to generate the binding from.
+// Deprecated: Use ScriptBaseMetaData.ABI instead.
+var ScriptBaseABI = ScriptBaseMetaData.ABI
+
+// ScriptBase is an auto generated Go binding around an Ethereum contract.
+type ScriptBase struct {
+	ScriptBaseCaller     // Read-only binding to the contract
+	ScriptBaseTransactor // Write-only binding to the contract
+	ScriptBaseFilterer   // Log filterer for contract events
+}
+
+// ScriptBaseCaller is an auto generated read-only Go binding around an Ethereum contract.
+type ScriptBaseCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ScriptBaseTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type ScriptBaseTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ScriptBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type ScriptBaseFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ScriptBaseSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type ScriptBaseSession struct {
+	Contract     *ScriptBase       // 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
+}
+
+// ScriptBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type ScriptBaseCallerSession struct {
+	Contract *ScriptBaseCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts     // Call options to use throughout this session
+}
+
+// ScriptBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type ScriptBaseTransactorSession struct {
+	Contract     *ScriptBaseTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
+}
+
+// ScriptBaseRaw is an auto generated low-level Go binding around an Ethereum contract.
+type ScriptBaseRaw struct {
+	Contract *ScriptBase // Generic contract binding to access the raw methods on
+}
+
+// ScriptBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type ScriptBaseCallerRaw struct {
+	Contract *ScriptBaseCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// ScriptBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type ScriptBaseTransactorRaw struct {
+	Contract *ScriptBaseTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewScriptBase creates a new instance of ScriptBase, bound to a specific deployed contract.
+func NewScriptBase(address common.Address, backend bind.ContractBackend) (*ScriptBase, error) {
+	contract, err := bindScriptBase(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &ScriptBase{ScriptBaseCaller: ScriptBaseCaller{contract: contract}, ScriptBaseTransactor: ScriptBaseTransactor{contract: contract}, ScriptBaseFilterer: ScriptBaseFilterer{contract: contract}}, nil
+}
+
+// NewScriptBaseCaller creates a new read-only instance of ScriptBase, bound to a specific deployed contract.
+func NewScriptBaseCaller(address common.Address, caller bind.ContractCaller) (*ScriptBaseCaller, error) {
+	contract, err := bindScriptBase(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ScriptBaseCaller{contract: contract}, nil
+}
+
+// NewScriptBaseTransactor creates a new write-only instance of ScriptBase, bound to a specific deployed contract.
+func NewScriptBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*ScriptBaseTransactor, error) {
+	contract, err := bindScriptBase(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ScriptBaseTransactor{contract: contract}, nil
+}
+
+// NewScriptBaseFilterer creates a new log filterer instance of ScriptBase, bound to a specific deployed contract.
+func NewScriptBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*ScriptBaseFilterer, error) {
+	contract, err := bindScriptBase(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &ScriptBaseFilterer{contract: contract}, nil
+}
+
+// bindScriptBase binds a generic wrapper to an already deployed contract.
+func bindScriptBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := ScriptBaseMetaData.GetAbi()
+	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 (_ScriptBase *ScriptBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _ScriptBase.Contract.ScriptBaseCaller.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 (_ScriptBase *ScriptBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _ScriptBase.Contract.ScriptBaseTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_ScriptBase *ScriptBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _ScriptBase.Contract.ScriptBaseTransactor.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 (_ScriptBase *ScriptBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _ScriptBase.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 (_ScriptBase *ScriptBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _ScriptBase.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_ScriptBase *ScriptBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _ScriptBase.Contract.contract.Transact(opts, method, params...)
+}
+
+// Sha2ExtMetaData contains all meta data concerning the Sha2Ext contract.
+var Sha2ExtMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220ac62b6cce21d343969b66e04212c86c9cf0917d19472f8e50bec4a4b6887c87664736f6c63430008190033",
+}
+
+// Sha2ExtABI is the input ABI used to generate the binding from.
+// Deprecated: Use Sha2ExtMetaData.ABI instead.
+var Sha2ExtABI = Sha2ExtMetaData.ABI
+
+// Sha2ExtBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use Sha2ExtMetaData.Bin instead.
+var Sha2ExtBin = Sha2ExtMetaData.Bin
+
+// DeploySha2Ext deploys a new Ethereum contract, binding an instance of Sha2Ext to it.
+func DeploySha2Ext(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Sha2Ext, error) {
+	parsed, err := Sha2ExtMetaData.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(Sha2ExtBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &Sha2Ext{Sha2ExtCaller: Sha2ExtCaller{contract: contract}, Sha2ExtTransactor: Sha2ExtTransactor{contract: contract}, Sha2ExtFilterer: Sha2ExtFilterer{contract: contract}}, nil
+}
+
+// Sha2Ext is an auto generated Go binding around an Ethereum contract.
+type Sha2Ext struct {
+	Sha2ExtCaller     // Read-only binding to the contract
+	Sha2ExtTransactor // Write-only binding to the contract
+	Sha2ExtFilterer   // Log filterer for contract events
+}
+
+// Sha2ExtCaller is an auto generated read-only Go binding around an Ethereum contract.
+type Sha2ExtCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Sha2ExtTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type Sha2ExtTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Sha2ExtFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type Sha2ExtFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Sha2ExtSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type Sha2ExtSession struct {
+	Contract     *Sha2Ext          // 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
+}
+
+// Sha2ExtCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type Sha2ExtCallerSession struct {
+	Contract *Sha2ExtCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts  // Call options to use throughout this session
+}
+
+// Sha2ExtTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type Sha2ExtTransactorSession struct {
+	Contract     *Sha2ExtTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
+}
+
+// Sha2ExtRaw is an auto generated low-level Go binding around an Ethereum contract.
+type Sha2ExtRaw struct {
+	Contract *Sha2Ext // Generic contract binding to access the raw methods on
+}
+
+// Sha2ExtCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type Sha2ExtCallerRaw struct {
+	Contract *Sha2ExtCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// Sha2ExtTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type Sha2ExtTransactorRaw struct {
+	Contract *Sha2ExtTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewSha2Ext creates a new instance of Sha2Ext, bound to a specific deployed contract.
+func NewSha2Ext(address common.Address, backend bind.ContractBackend) (*Sha2Ext, error) {
+	contract, err := bindSha2Ext(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Sha2Ext{Sha2ExtCaller: Sha2ExtCaller{contract: contract}, Sha2ExtTransactor: Sha2ExtTransactor{contract: contract}, Sha2ExtFilterer: Sha2ExtFilterer{contract: contract}}, nil
+}
+
+// NewSha2ExtCaller creates a new read-only instance of Sha2Ext, bound to a specific deployed contract.
+func NewSha2ExtCaller(address common.Address, caller bind.ContractCaller) (*Sha2ExtCaller, error) {
+	contract, err := bindSha2Ext(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &Sha2ExtCaller{contract: contract}, nil
+}
+
+// NewSha2ExtTransactor creates a new write-only instance of Sha2Ext, bound to a specific deployed contract.
+func NewSha2ExtTransactor(address common.Address, transactor bind.ContractTransactor) (*Sha2ExtTransactor, error) {
+	contract, err := bindSha2Ext(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &Sha2ExtTransactor{contract: contract}, nil
+}
+
+// NewSha2ExtFilterer creates a new log filterer instance of Sha2Ext, bound to a specific deployed contract.
+func NewSha2ExtFilterer(address common.Address, filterer bind.ContractFilterer) (*Sha2ExtFilterer, error) {
+	contract, err := bindSha2Ext(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &Sha2ExtFilterer{contract: contract}, nil
+}
+
+// bindSha2Ext binds a generic wrapper to an already deployed contract.
+func bindSha2Ext(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := Sha2ExtMetaData.GetAbi()
+	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 (_Sha2Ext *Sha2ExtRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Sha2Ext.Contract.Sha2ExtCaller.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 (_Sha2Ext *Sha2ExtRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Sha2Ext.Contract.Sha2ExtTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Sha2Ext *Sha2ExtRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Sha2Ext.Contract.Sha2ExtTransactor.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 (_Sha2Ext *Sha2ExtCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Sha2Ext.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 (_Sha2Ext *Sha2ExtTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Sha2Ext.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Sha2Ext *Sha2ExtTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Sha2Ext.Contract.contract.Transact(opts, method, params...)
+}
+
+// SigVerifyBaseMetaData contains all meta data concerning the SigVerifyBase contract.
+var SigVerifyBaseMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"P256_VERIFIER\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"x509\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+}
+
+// SigVerifyBaseABI is the input ABI used to generate the binding from.
+// Deprecated: Use SigVerifyBaseMetaData.ABI instead.
+var SigVerifyBaseABI = SigVerifyBaseMetaData.ABI
+
+// SigVerifyBase is an auto generated Go binding around an Ethereum contract.
+type SigVerifyBase struct {
+	SigVerifyBaseCaller     // Read-only binding to the contract
+	SigVerifyBaseTransactor // Write-only binding to the contract
+	SigVerifyBaseFilterer   // Log filterer for contract events
+}
+
+// SigVerifyBaseCaller is an auto generated read-only Go binding around an Ethereum contract.
+type SigVerifyBaseCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// SigVerifyBaseTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type SigVerifyBaseTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// SigVerifyBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type SigVerifyBaseFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// SigVerifyBaseSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type SigVerifyBaseSession struct {
+	Contract     *SigVerifyBase    // 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
+}
+
+// SigVerifyBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type SigVerifyBaseCallerSession struct {
+	Contract *SigVerifyBaseCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts        // Call options to use throughout this session
+}
+
+// SigVerifyBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type SigVerifyBaseTransactorSession struct {
+	Contract     *SigVerifyBaseTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
+}
+
+// SigVerifyBaseRaw is an auto generated low-level Go binding around an Ethereum contract.
+type SigVerifyBaseRaw struct {
+	Contract *SigVerifyBase // Generic contract binding to access the raw methods on
+}
+
+// SigVerifyBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type SigVerifyBaseCallerRaw struct {
+	Contract *SigVerifyBaseCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// SigVerifyBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type SigVerifyBaseTransactorRaw struct {
+	Contract *SigVerifyBaseTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewSigVerifyBase creates a new instance of SigVerifyBase, bound to a specific deployed contract.
+func NewSigVerifyBase(address common.Address, backend bind.ContractBackend) (*SigVerifyBase, error) {
+	contract, err := bindSigVerifyBase(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &SigVerifyBase{SigVerifyBaseCaller: SigVerifyBaseCaller{contract: contract}, SigVerifyBaseTransactor: SigVerifyBaseTransactor{contract: contract}, SigVerifyBaseFilterer: SigVerifyBaseFilterer{contract: contract}}, nil
+}
+
+// NewSigVerifyBaseCaller creates a new read-only instance of SigVerifyBase, bound to a specific deployed contract.
+func NewSigVerifyBaseCaller(address common.Address, caller bind.ContractCaller) (*SigVerifyBaseCaller, error) {
+	contract, err := bindSigVerifyBase(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &SigVerifyBaseCaller{contract: contract}, nil
+}
+
+// NewSigVerifyBaseTransactor creates a new write-only instance of SigVerifyBase, bound to a specific deployed contract.
+func NewSigVerifyBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*SigVerifyBaseTransactor, error) {
+	contract, err := bindSigVerifyBase(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &SigVerifyBaseTransactor{contract: contract}, nil
+}
+
+// NewSigVerifyBaseFilterer creates a new log filterer instance of SigVerifyBase, bound to a specific deployed contract.
+func NewSigVerifyBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*SigVerifyBaseFilterer, error) {
+	contract, err := bindSigVerifyBase(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &SigVerifyBaseFilterer{contract: contract}, nil
+}
+
+// bindSigVerifyBase binds a generic wrapper to an already deployed contract.
+func bindSigVerifyBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := SigVerifyBaseMetaData.GetAbi()
+	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 (_SigVerifyBase *SigVerifyBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _SigVerifyBase.Contract.SigVerifyBaseCaller.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 (_SigVerifyBase *SigVerifyBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _SigVerifyBase.Contract.SigVerifyBaseTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_SigVerifyBase *SigVerifyBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _SigVerifyBase.Contract.SigVerifyBaseTransactor.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 (_SigVerifyBase *SigVerifyBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _SigVerifyBase.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 (_SigVerifyBase *SigVerifyBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _SigVerifyBase.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_SigVerifyBase *SigVerifyBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _SigVerifyBase.Contract.contract.Transact(opts, method, params...)
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_SigVerifyBase *SigVerifyBaseCaller) P256VERIFIER(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _SigVerifyBase.contract.Call(opts, &out, "P256_VERIFIER")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_SigVerifyBase *SigVerifyBaseSession) P256VERIFIER() (common.Address, error) {
+	return _SigVerifyBase.Contract.P256VERIFIER(&_SigVerifyBase.CallOpts)
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_SigVerifyBase *SigVerifyBaseCallerSession) P256VERIFIER() (common.Address, error) {
+	return _SigVerifyBase.Contract.P256VERIFIER(&_SigVerifyBase.CallOpts)
+}
+
+// X509 is a free data retrieval call binding the contract method 0xec950d33.
+//
+// Solidity: function x509() view returns(address)
+func (_SigVerifyBase *SigVerifyBaseCaller) X509(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _SigVerifyBase.contract.Call(opts, &out, "x509")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// X509 is a free data retrieval call binding the contract method 0xec950d33.
+//
+// Solidity: function x509() view returns(address)
+func (_SigVerifyBase *SigVerifyBaseSession) X509() (common.Address, error) {
+	return _SigVerifyBase.Contract.X509(&_SigVerifyBase.CallOpts)
+}
+
+// X509 is a free data retrieval call binding the contract method 0xec950d33.
+//
+// Solidity: function x509() view returns(address)
+func (_SigVerifyBase *SigVerifyBaseCallerSession) X509() (common.Address, error) {
+	return _SigVerifyBase.Contract.X509(&_SigVerifyBase.CallOpts)
+}
+
+// StdAssertionsMetaData contains all meta data concerning the StdAssertions contract.
+var StdAssertionsMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"}]",
+}
+
+// StdAssertionsABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdAssertionsMetaData.ABI instead.
+var StdAssertionsABI = StdAssertionsMetaData.ABI
+
+// StdAssertions is an auto generated Go binding around an Ethereum contract.
+type StdAssertions struct {
+	StdAssertionsCaller     // Read-only binding to the contract
+	StdAssertionsTransactor // Write-only binding to the contract
+	StdAssertionsFilterer   // Log filterer for contract events
+}
+
+// StdAssertionsCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdAssertionsCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdAssertionsTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdAssertionsTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdAssertionsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdAssertionsFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdAssertionsSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdAssertionsSession struct {
+	Contract     *StdAssertions    // 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
+}
+
+// StdAssertionsCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdAssertionsCallerSession struct {
+	Contract *StdAssertionsCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts        // Call options to use throughout this session
+}
+
+// StdAssertionsTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdAssertionsTransactorSession struct {
+	Contract     *StdAssertionsTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
+}
+
+// StdAssertionsRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdAssertionsRaw struct {
+	Contract *StdAssertions // Generic contract binding to access the raw methods on
+}
+
+// StdAssertionsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdAssertionsCallerRaw struct {
+	Contract *StdAssertionsCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdAssertionsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdAssertionsTransactorRaw struct {
+	Contract *StdAssertionsTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdAssertions creates a new instance of StdAssertions, bound to a specific deployed contract.
+func NewStdAssertions(address common.Address, backend bind.ContractBackend) (*StdAssertions, error) {
+	contract, err := bindStdAssertions(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertions{StdAssertionsCaller: StdAssertionsCaller{contract: contract}, StdAssertionsTransactor: StdAssertionsTransactor{contract: contract}, StdAssertionsFilterer: StdAssertionsFilterer{contract: contract}}, nil
+}
+
+// NewStdAssertionsCaller creates a new read-only instance of StdAssertions, bound to a specific deployed contract.
+func NewStdAssertionsCaller(address common.Address, caller bind.ContractCaller) (*StdAssertionsCaller, error) {
+	contract, err := bindStdAssertions(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsCaller{contract: contract}, nil
+}
+
+// NewStdAssertionsTransactor creates a new write-only instance of StdAssertions, bound to a specific deployed contract.
+func NewStdAssertionsTransactor(address common.Address, transactor bind.ContractTransactor) (*StdAssertionsTransactor, error) {
+	contract, err := bindStdAssertions(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsTransactor{contract: contract}, nil
+}
+
+// NewStdAssertionsFilterer creates a new log filterer instance of StdAssertions, bound to a specific deployed contract.
+func NewStdAssertionsFilterer(address common.Address, filterer bind.ContractFilterer) (*StdAssertionsFilterer, error) {
+	contract, err := bindStdAssertions(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsFilterer{contract: contract}, nil
+}
+
+// bindStdAssertions binds a generic wrapper to an already deployed contract.
+func bindStdAssertions(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdAssertionsMetaData.GetAbi()
+	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 (_StdAssertions *StdAssertionsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdAssertions.Contract.StdAssertionsCaller.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 (_StdAssertions *StdAssertionsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdAssertions.Contract.StdAssertionsTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdAssertions *StdAssertionsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdAssertions.Contract.StdAssertionsTransactor.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 (_StdAssertions *StdAssertionsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdAssertions.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 (_StdAssertions *StdAssertionsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdAssertions.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdAssertions *StdAssertionsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdAssertions.Contract.contract.Transact(opts, method, params...)
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_StdAssertions *StdAssertionsCaller) Failed(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _StdAssertions.contract.Call(opts, &out, "failed")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_StdAssertions *StdAssertionsSession) Failed() (bool, error) {
+	return _StdAssertions.Contract.Failed(&_StdAssertions.CallOpts)
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_StdAssertions *StdAssertionsCallerSession) Failed() (bool, error) {
+	return _StdAssertions.Contract.Failed(&_StdAssertions.CallOpts)
+}
+
+// StdAssertionsLogIterator is returned from FilterLog and is used to iterate over the raw logs and unpacked data for Log events raised by the StdAssertions contract.
+type StdAssertionsLogIterator struct {
+	Event *StdAssertionsLog // 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 *StdAssertionsLogIterator) 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(StdAssertionsLog)
+			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(StdAssertionsLog)
+		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 *StdAssertionsLogIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLog represents a Log event raised by the StdAssertions contract.
+type StdAssertionsLog struct {
+	Arg0 string
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLog is a free log retrieval operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_StdAssertions *StdAssertionsFilterer) FilterLog(opts *bind.FilterOpts) (*StdAssertionsLogIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogIterator{contract: _StdAssertions.contract, event: "log", logs: logs, sub: sub}, nil
+}
+
+// WatchLog is a free log subscription operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_StdAssertions *StdAssertionsFilterer) WatchLog(opts *bind.WatchOpts, sink chan<- *StdAssertionsLog) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log")
+	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(StdAssertionsLog)
+				if err := _StdAssertions.contract.UnpackLog(event, "log", 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
+}
+
+// ParseLog is a log parse operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_StdAssertions *StdAssertionsFilterer) ParseLog(log types.Log) (*StdAssertionsLog, error) {
+	event := new(StdAssertionsLog)
+	if err := _StdAssertions.contract.UnpackLog(event, "log", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogAddressIterator is returned from FilterLogAddress and is used to iterate over the raw logs and unpacked data for LogAddress events raised by the StdAssertions contract.
+type StdAssertionsLogAddressIterator struct {
+	Event *StdAssertionsLogAddress // 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 *StdAssertionsLogAddressIterator) 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(StdAssertionsLogAddress)
+			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(StdAssertionsLogAddress)
+		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 *StdAssertionsLogAddressIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogAddressIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogAddress represents a LogAddress event raised by the StdAssertions contract.
+type StdAssertionsLogAddress struct {
+	Arg0 common.Address
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogAddress is a free log retrieval operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogAddress(opts *bind.FilterOpts) (*StdAssertionsLogAddressIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_address")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogAddressIterator{contract: _StdAssertions.contract, event: "log_address", logs: logs, sub: sub}, nil
+}
+
+// WatchLogAddress is a free log subscription operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogAddress(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogAddress) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_address")
+	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(StdAssertionsLogAddress)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_address", 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
+}
+
+// ParseLogAddress is a log parse operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogAddress(log types.Log) (*StdAssertionsLogAddress, error) {
+	event := new(StdAssertionsLogAddress)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_address", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogArrayIterator is returned from FilterLogArray and is used to iterate over the raw logs and unpacked data for LogArray events raised by the StdAssertions contract.
+type StdAssertionsLogArrayIterator struct {
+	Event *StdAssertionsLogArray // 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 *StdAssertionsLogArrayIterator) 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(StdAssertionsLogArray)
+			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(StdAssertionsLogArray)
+		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 *StdAssertionsLogArrayIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogArrayIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogArray represents a LogArray event raised by the StdAssertions contract.
+type StdAssertionsLogArray struct {
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray is a free log retrieval operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogArray(opts *bind.FilterOpts) (*StdAssertionsLogArrayIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_array")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogArrayIterator{contract: _StdAssertions.contract, event: "log_array", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray is a free log subscription operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogArray(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogArray) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_array")
+	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(StdAssertionsLogArray)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_array", 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
+}
+
+// ParseLogArray is a log parse operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogArray(log types.Log) (*StdAssertionsLogArray, error) {
+	event := new(StdAssertionsLogArray)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_array", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogArray0Iterator is returned from FilterLogArray0 and is used to iterate over the raw logs and unpacked data for LogArray0 events raised by the StdAssertions contract.
+type StdAssertionsLogArray0Iterator struct {
+	Event *StdAssertionsLogArray0 // 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 *StdAssertionsLogArray0Iterator) 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(StdAssertionsLogArray0)
+			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(StdAssertionsLogArray0)
+		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 *StdAssertionsLogArray0Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogArray0Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogArray0 represents a LogArray0 event raised by the StdAssertions contract.
+type StdAssertionsLogArray0 struct {
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray0 is a free log retrieval operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogArray0(opts *bind.FilterOpts) (*StdAssertionsLogArray0Iterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_array0")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogArray0Iterator{contract: _StdAssertions.contract, event: "log_array0", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray0 is a free log subscription operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogArray0(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogArray0) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_array0")
+	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(StdAssertionsLogArray0)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_array0", 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
+}
+
+// ParseLogArray0 is a log parse operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogArray0(log types.Log) (*StdAssertionsLogArray0, error) {
+	event := new(StdAssertionsLogArray0)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_array0", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogArray1Iterator is returned from FilterLogArray1 and is used to iterate over the raw logs and unpacked data for LogArray1 events raised by the StdAssertions contract.
+type StdAssertionsLogArray1Iterator struct {
+	Event *StdAssertionsLogArray1 // 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 *StdAssertionsLogArray1Iterator) 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(StdAssertionsLogArray1)
+			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(StdAssertionsLogArray1)
+		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 *StdAssertionsLogArray1Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogArray1Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogArray1 represents a LogArray1 event raised by the StdAssertions contract.
+type StdAssertionsLogArray1 struct {
+	Val []common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray1 is a free log retrieval operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogArray1(opts *bind.FilterOpts) (*StdAssertionsLogArray1Iterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_array1")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogArray1Iterator{contract: _StdAssertions.contract, event: "log_array1", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray1 is a free log subscription operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogArray1(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogArray1) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_array1")
+	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(StdAssertionsLogArray1)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_array1", 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
+}
+
+// ParseLogArray1 is a log parse operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogArray1(log types.Log) (*StdAssertionsLogArray1, error) {
+	event := new(StdAssertionsLogArray1)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_array1", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogBytesIterator is returned from FilterLogBytes and is used to iterate over the raw logs and unpacked data for LogBytes events raised by the StdAssertions contract.
+type StdAssertionsLogBytesIterator struct {
+	Event *StdAssertionsLogBytes // 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 *StdAssertionsLogBytesIterator) 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(StdAssertionsLogBytes)
+			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(StdAssertionsLogBytes)
+		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 *StdAssertionsLogBytesIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogBytesIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogBytes represents a LogBytes event raised by the StdAssertions contract.
+type StdAssertionsLogBytes struct {
+	Arg0 []byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogBytes is a free log retrieval operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogBytes(opts *bind.FilterOpts) (*StdAssertionsLogBytesIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_bytes")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogBytesIterator{contract: _StdAssertions.contract, event: "log_bytes", logs: logs, sub: sub}, nil
+}
+
+// WatchLogBytes is a free log subscription operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogBytes(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogBytes) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_bytes")
+	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(StdAssertionsLogBytes)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_bytes", 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
+}
+
+// ParseLogBytes is a log parse operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogBytes(log types.Log) (*StdAssertionsLogBytes, error) {
+	event := new(StdAssertionsLogBytes)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_bytes", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogBytes32Iterator is returned from FilterLogBytes32 and is used to iterate over the raw logs and unpacked data for LogBytes32 events raised by the StdAssertions contract.
+type StdAssertionsLogBytes32Iterator struct {
+	Event *StdAssertionsLogBytes32 // 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 *StdAssertionsLogBytes32Iterator) 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(StdAssertionsLogBytes32)
+			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(StdAssertionsLogBytes32)
+		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 *StdAssertionsLogBytes32Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogBytes32Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogBytes32 represents a LogBytes32 event raised by the StdAssertions contract.
+type StdAssertionsLogBytes32 struct {
+	Arg0 [32]byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogBytes32 is a free log retrieval operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogBytes32(opts *bind.FilterOpts) (*StdAssertionsLogBytes32Iterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_bytes32")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogBytes32Iterator{contract: _StdAssertions.contract, event: "log_bytes32", logs: logs, sub: sub}, nil
+}
+
+// WatchLogBytes32 is a free log subscription operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogBytes32(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogBytes32) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_bytes32")
+	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(StdAssertionsLogBytes32)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_bytes32", 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
+}
+
+// ParseLogBytes32 is a log parse operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogBytes32(log types.Log) (*StdAssertionsLogBytes32, error) {
+	event := new(StdAssertionsLogBytes32)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_bytes32", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogIntIterator is returned from FilterLogInt and is used to iterate over the raw logs and unpacked data for LogInt events raised by the StdAssertions contract.
+type StdAssertionsLogIntIterator struct {
+	Event *StdAssertionsLogInt // 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 *StdAssertionsLogIntIterator) 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(StdAssertionsLogInt)
+			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(StdAssertionsLogInt)
+		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 *StdAssertionsLogIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogInt represents a LogInt event raised by the StdAssertions contract.
+type StdAssertionsLogInt struct {
+	Arg0 *big.Int
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogInt is a free log retrieval operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogInt(opts *bind.FilterOpts) (*StdAssertionsLogIntIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_int")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogIntIterator{contract: _StdAssertions.contract, event: "log_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogInt is a free log subscription operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogInt(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogInt) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_int")
+	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(StdAssertionsLogInt)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_int", 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
+}
+
+// ParseLogInt is a log parse operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogInt(log types.Log) (*StdAssertionsLogInt, error) {
+	event := new(StdAssertionsLogInt)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogNamedAddressIterator is returned from FilterLogNamedAddress and is used to iterate over the raw logs and unpacked data for LogNamedAddress events raised by the StdAssertions contract.
+type StdAssertionsLogNamedAddressIterator struct {
+	Event *StdAssertionsLogNamedAddress // 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 *StdAssertionsLogNamedAddressIterator) 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(StdAssertionsLogNamedAddress)
+			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(StdAssertionsLogNamedAddress)
+		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 *StdAssertionsLogNamedAddressIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogNamedAddressIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogNamedAddress represents a LogNamedAddress event raised by the StdAssertions contract.
+type StdAssertionsLogNamedAddress struct {
+	Key string
+	Val common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedAddress is a free log retrieval operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedAddress(opts *bind.FilterOpts) (*StdAssertionsLogNamedAddressIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_address")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogNamedAddressIterator{contract: _StdAssertions.contract, event: "log_named_address", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedAddress is a free log subscription operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedAddress(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedAddress) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_address")
+	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(StdAssertionsLogNamedAddress)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_named_address", 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
+}
+
+// ParseLogNamedAddress is a log parse operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedAddress(log types.Log) (*StdAssertionsLogNamedAddress, error) {
+	event := new(StdAssertionsLogNamedAddress)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_named_address", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogNamedArrayIterator is returned from FilterLogNamedArray and is used to iterate over the raw logs and unpacked data for LogNamedArray events raised by the StdAssertions contract.
+type StdAssertionsLogNamedArrayIterator struct {
+	Event *StdAssertionsLogNamedArray // 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 *StdAssertionsLogNamedArrayIterator) 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(StdAssertionsLogNamedArray)
+			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(StdAssertionsLogNamedArray)
+		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 *StdAssertionsLogNamedArrayIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogNamedArrayIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogNamedArray represents a LogNamedArray event raised by the StdAssertions contract.
+type StdAssertionsLogNamedArray struct {
+	Key string
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray is a free log retrieval operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedArray(opts *bind.FilterOpts) (*StdAssertionsLogNamedArrayIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_array")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogNamedArrayIterator{contract: _StdAssertions.contract, event: "log_named_array", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray is a free log subscription operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedArray(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedArray) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_array")
+	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(StdAssertionsLogNamedArray)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_named_array", 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
+}
+
+// ParseLogNamedArray is a log parse operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedArray(log types.Log) (*StdAssertionsLogNamedArray, error) {
+	event := new(StdAssertionsLogNamedArray)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_named_array", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogNamedArray0Iterator is returned from FilterLogNamedArray0 and is used to iterate over the raw logs and unpacked data for LogNamedArray0 events raised by the StdAssertions contract.
+type StdAssertionsLogNamedArray0Iterator struct {
+	Event *StdAssertionsLogNamedArray0 // 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 *StdAssertionsLogNamedArray0Iterator) 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(StdAssertionsLogNamedArray0)
+			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(StdAssertionsLogNamedArray0)
+		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 *StdAssertionsLogNamedArray0Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogNamedArray0Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogNamedArray0 represents a LogNamedArray0 event raised by the StdAssertions contract.
+type StdAssertionsLogNamedArray0 struct {
+	Key string
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray0 is a free log retrieval operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedArray0(opts *bind.FilterOpts) (*StdAssertionsLogNamedArray0Iterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_array0")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogNamedArray0Iterator{contract: _StdAssertions.contract, event: "log_named_array0", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray0 is a free log subscription operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedArray0(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedArray0) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_array0")
+	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(StdAssertionsLogNamedArray0)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_named_array0", 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
+}
+
+// ParseLogNamedArray0 is a log parse operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedArray0(log types.Log) (*StdAssertionsLogNamedArray0, error) {
+	event := new(StdAssertionsLogNamedArray0)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_named_array0", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogNamedArray1Iterator is returned from FilterLogNamedArray1 and is used to iterate over the raw logs and unpacked data for LogNamedArray1 events raised by the StdAssertions contract.
+type StdAssertionsLogNamedArray1Iterator struct {
+	Event *StdAssertionsLogNamedArray1 // 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 *StdAssertionsLogNamedArray1Iterator) 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(StdAssertionsLogNamedArray1)
+			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(StdAssertionsLogNamedArray1)
+		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 *StdAssertionsLogNamedArray1Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogNamedArray1Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogNamedArray1 represents a LogNamedArray1 event raised by the StdAssertions contract.
+type StdAssertionsLogNamedArray1 struct {
+	Key string
+	Val []common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray1 is a free log retrieval operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedArray1(opts *bind.FilterOpts) (*StdAssertionsLogNamedArray1Iterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_array1")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogNamedArray1Iterator{contract: _StdAssertions.contract, event: "log_named_array1", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray1 is a free log subscription operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedArray1(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedArray1) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_array1")
+	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(StdAssertionsLogNamedArray1)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_named_array1", 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
+}
+
+// ParseLogNamedArray1 is a log parse operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedArray1(log types.Log) (*StdAssertionsLogNamedArray1, error) {
+	event := new(StdAssertionsLogNamedArray1)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_named_array1", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogNamedBytesIterator is returned from FilterLogNamedBytes and is used to iterate over the raw logs and unpacked data for LogNamedBytes events raised by the StdAssertions contract.
+type StdAssertionsLogNamedBytesIterator struct {
+	Event *StdAssertionsLogNamedBytes // 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 *StdAssertionsLogNamedBytesIterator) 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(StdAssertionsLogNamedBytes)
+			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(StdAssertionsLogNamedBytes)
+		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 *StdAssertionsLogNamedBytesIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogNamedBytesIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogNamedBytes represents a LogNamedBytes event raised by the StdAssertions contract.
+type StdAssertionsLogNamedBytes struct {
+	Key string
+	Val []byte
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedBytes is a free log retrieval operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedBytes(opts *bind.FilterOpts) (*StdAssertionsLogNamedBytesIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_bytes")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogNamedBytesIterator{contract: _StdAssertions.contract, event: "log_named_bytes", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedBytes is a free log subscription operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedBytes(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedBytes) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_bytes")
+	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(StdAssertionsLogNamedBytes)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_named_bytes", 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
+}
+
+// ParseLogNamedBytes is a log parse operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedBytes(log types.Log) (*StdAssertionsLogNamedBytes, error) {
+	event := new(StdAssertionsLogNamedBytes)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_named_bytes", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogNamedBytes32Iterator is returned from FilterLogNamedBytes32 and is used to iterate over the raw logs and unpacked data for LogNamedBytes32 events raised by the StdAssertions contract.
+type StdAssertionsLogNamedBytes32Iterator struct {
+	Event *StdAssertionsLogNamedBytes32 // 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 *StdAssertionsLogNamedBytes32Iterator) 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(StdAssertionsLogNamedBytes32)
+			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(StdAssertionsLogNamedBytes32)
+		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 *StdAssertionsLogNamedBytes32Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogNamedBytes32Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogNamedBytes32 represents a LogNamedBytes32 event raised by the StdAssertions contract.
+type StdAssertionsLogNamedBytes32 struct {
+	Key string
+	Val [32]byte
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedBytes32 is a free log retrieval operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedBytes32(opts *bind.FilterOpts) (*StdAssertionsLogNamedBytes32Iterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_bytes32")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogNamedBytes32Iterator{contract: _StdAssertions.contract, event: "log_named_bytes32", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedBytes32 is a free log subscription operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedBytes32(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedBytes32) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_bytes32")
+	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(StdAssertionsLogNamedBytes32)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_named_bytes32", 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
+}
+
+// ParseLogNamedBytes32 is a log parse operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedBytes32(log types.Log) (*StdAssertionsLogNamedBytes32, error) {
+	event := new(StdAssertionsLogNamedBytes32)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_named_bytes32", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogNamedDecimalIntIterator is returned from FilterLogNamedDecimalInt and is used to iterate over the raw logs and unpacked data for LogNamedDecimalInt events raised by the StdAssertions contract.
+type StdAssertionsLogNamedDecimalIntIterator struct {
+	Event *StdAssertionsLogNamedDecimalInt // 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 *StdAssertionsLogNamedDecimalIntIterator) 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(StdAssertionsLogNamedDecimalInt)
+			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(StdAssertionsLogNamedDecimalInt)
+		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 *StdAssertionsLogNamedDecimalIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogNamedDecimalIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogNamedDecimalInt represents a LogNamedDecimalInt event raised by the StdAssertions contract.
+type StdAssertionsLogNamedDecimalInt struct {
+	Key      string
+	Val      *big.Int
+	Decimals *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedDecimalInt is a free log retrieval operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedDecimalInt(opts *bind.FilterOpts) (*StdAssertionsLogNamedDecimalIntIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_decimal_int")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogNamedDecimalIntIterator{contract: _StdAssertions.contract, event: "log_named_decimal_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedDecimalInt is a free log subscription operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedDecimalInt(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedDecimalInt) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_decimal_int")
+	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(StdAssertionsLogNamedDecimalInt)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_named_decimal_int", 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
+}
+
+// ParseLogNamedDecimalInt is a log parse operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedDecimalInt(log types.Log) (*StdAssertionsLogNamedDecimalInt, error) {
+	event := new(StdAssertionsLogNamedDecimalInt)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogNamedDecimalUintIterator is returned from FilterLogNamedDecimalUint and is used to iterate over the raw logs and unpacked data for LogNamedDecimalUint events raised by the StdAssertions contract.
+type StdAssertionsLogNamedDecimalUintIterator struct {
+	Event *StdAssertionsLogNamedDecimalUint // 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 *StdAssertionsLogNamedDecimalUintIterator) 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(StdAssertionsLogNamedDecimalUint)
+			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(StdAssertionsLogNamedDecimalUint)
+		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 *StdAssertionsLogNamedDecimalUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogNamedDecimalUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogNamedDecimalUint represents a LogNamedDecimalUint event raised by the StdAssertions contract.
+type StdAssertionsLogNamedDecimalUint struct {
+	Key      string
+	Val      *big.Int
+	Decimals *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedDecimalUint is a free log retrieval operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedDecimalUint(opts *bind.FilterOpts) (*StdAssertionsLogNamedDecimalUintIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_decimal_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogNamedDecimalUintIterator{contract: _StdAssertions.contract, event: "log_named_decimal_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedDecimalUint is a free log subscription operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedDecimalUint(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedDecimalUint) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_decimal_uint")
+	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(StdAssertionsLogNamedDecimalUint)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_named_decimal_uint", 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
+}
+
+// ParseLogNamedDecimalUint is a log parse operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedDecimalUint(log types.Log) (*StdAssertionsLogNamedDecimalUint, error) {
+	event := new(StdAssertionsLogNamedDecimalUint)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogNamedIntIterator is returned from FilterLogNamedInt and is used to iterate over the raw logs and unpacked data for LogNamedInt events raised by the StdAssertions contract.
+type StdAssertionsLogNamedIntIterator struct {
+	Event *StdAssertionsLogNamedInt // 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 *StdAssertionsLogNamedIntIterator) 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(StdAssertionsLogNamedInt)
+			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(StdAssertionsLogNamedInt)
+		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 *StdAssertionsLogNamedIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogNamedIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogNamedInt represents a LogNamedInt event raised by the StdAssertions contract.
+type StdAssertionsLogNamedInt struct {
+	Key string
+	Val *big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedInt is a free log retrieval operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedInt(opts *bind.FilterOpts) (*StdAssertionsLogNamedIntIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_int")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogNamedIntIterator{contract: _StdAssertions.contract, event: "log_named_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedInt is a free log subscription operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedInt(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedInt) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_int")
+	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(StdAssertionsLogNamedInt)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_named_int", 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
+}
+
+// ParseLogNamedInt is a log parse operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedInt(log types.Log) (*StdAssertionsLogNamedInt, error) {
+	event := new(StdAssertionsLogNamedInt)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_named_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogNamedStringIterator is returned from FilterLogNamedString and is used to iterate over the raw logs and unpacked data for LogNamedString events raised by the StdAssertions contract.
+type StdAssertionsLogNamedStringIterator struct {
+	Event *StdAssertionsLogNamedString // 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 *StdAssertionsLogNamedStringIterator) 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(StdAssertionsLogNamedString)
+			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(StdAssertionsLogNamedString)
+		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 *StdAssertionsLogNamedStringIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogNamedStringIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogNamedString represents a LogNamedString event raised by the StdAssertions contract.
+type StdAssertionsLogNamedString struct {
+	Key string
+	Val string
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedString is a free log retrieval operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedString(opts *bind.FilterOpts) (*StdAssertionsLogNamedStringIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_string")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogNamedStringIterator{contract: _StdAssertions.contract, event: "log_named_string", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedString is a free log subscription operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedString(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedString) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_string")
+	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(StdAssertionsLogNamedString)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_named_string", 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
+}
+
+// ParseLogNamedString is a log parse operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedString(log types.Log) (*StdAssertionsLogNamedString, error) {
+	event := new(StdAssertionsLogNamedString)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_named_string", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogNamedUintIterator is returned from FilterLogNamedUint and is used to iterate over the raw logs and unpacked data for LogNamedUint events raised by the StdAssertions contract.
+type StdAssertionsLogNamedUintIterator struct {
+	Event *StdAssertionsLogNamedUint // 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 *StdAssertionsLogNamedUintIterator) 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(StdAssertionsLogNamedUint)
+			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(StdAssertionsLogNamedUint)
+		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 *StdAssertionsLogNamedUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogNamedUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogNamedUint represents a LogNamedUint event raised by the StdAssertions contract.
+type StdAssertionsLogNamedUint struct {
+	Key string
+	Val *big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedUint is a free log retrieval operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedUint(opts *bind.FilterOpts) (*StdAssertionsLogNamedUintIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogNamedUintIterator{contract: _StdAssertions.contract, event: "log_named_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedUint is a free log subscription operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedUint(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedUint) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_uint")
+	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(StdAssertionsLogNamedUint)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_named_uint", 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
+}
+
+// ParseLogNamedUint is a log parse operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedUint(log types.Log) (*StdAssertionsLogNamedUint, error) {
+	event := new(StdAssertionsLogNamedUint)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_named_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogStringIterator is returned from FilterLogString and is used to iterate over the raw logs and unpacked data for LogString events raised by the StdAssertions contract.
+type StdAssertionsLogStringIterator struct {
+	Event *StdAssertionsLogString // 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 *StdAssertionsLogStringIterator) 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(StdAssertionsLogString)
+			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(StdAssertionsLogString)
+		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 *StdAssertionsLogStringIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogStringIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogString represents a LogString event raised by the StdAssertions contract.
+type StdAssertionsLogString struct {
+	Arg0 string
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogString is a free log retrieval operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogString(opts *bind.FilterOpts) (*StdAssertionsLogStringIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_string")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogStringIterator{contract: _StdAssertions.contract, event: "log_string", logs: logs, sub: sub}, nil
+}
+
+// WatchLogString is a free log subscription operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogString(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogString) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_string")
+	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(StdAssertionsLogString)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_string", 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
+}
+
+// ParseLogString is a log parse operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogString(log types.Log) (*StdAssertionsLogString, error) {
+	event := new(StdAssertionsLogString)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_string", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogUintIterator is returned from FilterLogUint and is used to iterate over the raw logs and unpacked data for LogUint events raised by the StdAssertions contract.
+type StdAssertionsLogUintIterator struct {
+	Event *StdAssertionsLogUint // 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 *StdAssertionsLogUintIterator) 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(StdAssertionsLogUint)
+			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(StdAssertionsLogUint)
+		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 *StdAssertionsLogUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogUint represents a LogUint event raised by the StdAssertions contract.
+type StdAssertionsLogUint struct {
+	Arg0 *big.Int
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogUint is a free log retrieval operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogUint(opts *bind.FilterOpts) (*StdAssertionsLogUintIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogUintIterator{contract: _StdAssertions.contract, event: "log_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogUint is a free log subscription operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogUint(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogUint) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_uint")
+	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(StdAssertionsLogUint)
+				if err := _StdAssertions.contract.UnpackLog(event, "log_uint", 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
+}
+
+// ParseLogUint is a log parse operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogUint(log types.Log) (*StdAssertionsLogUint, error) {
+	event := new(StdAssertionsLogUint)
+	if err := _StdAssertions.contract.UnpackLog(event, "log_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdAssertionsLogsIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for Logs events raised by the StdAssertions contract.
+type StdAssertionsLogsIterator struct {
+	Event *StdAssertionsLogs // 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 *StdAssertionsLogsIterator) 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(StdAssertionsLogs)
+			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(StdAssertionsLogs)
+		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 *StdAssertionsLogsIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdAssertionsLogsIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdAssertionsLogs represents a Logs event raised by the StdAssertions contract.
+type StdAssertionsLogs struct {
+	Arg0 []byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogs is a free log retrieval operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_StdAssertions *StdAssertionsFilterer) FilterLogs(opts *bind.FilterOpts) (*StdAssertionsLogsIterator, error) {
+
+	logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "logs")
+	if err != nil {
+		return nil, err
+	}
+	return &StdAssertionsLogsIterator{contract: _StdAssertions.contract, event: "logs", logs: logs, sub: sub}, nil
+}
+
+// WatchLogs is a free log subscription operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_StdAssertions *StdAssertionsFilterer) WatchLogs(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogs) (event.Subscription, error) {
+
+	logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "logs")
+	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(StdAssertionsLogs)
+				if err := _StdAssertions.contract.UnpackLog(event, "logs", 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
+}
+
+// ParseLogs is a log parse operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_StdAssertions *StdAssertionsFilterer) ParseLogs(log types.Log) (*StdAssertionsLogs, error) {
+	event := new(StdAssertionsLogs)
+	if err := _StdAssertions.contract.UnpackLog(event, "logs", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdChainsMetaData contains all meta data concerning the StdChains contract.
+var StdChainsMetaData = &bind.MetaData{
+	ABI: "[]",
+}
+
+// StdChainsABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdChainsMetaData.ABI instead.
+var StdChainsABI = StdChainsMetaData.ABI
+
+// StdChains is an auto generated Go binding around an Ethereum contract.
+type StdChains struct {
+	StdChainsCaller     // Read-only binding to the contract
+	StdChainsTransactor // Write-only binding to the contract
+	StdChainsFilterer   // Log filterer for contract events
+}
+
+// StdChainsCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdChainsCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdChainsTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdChainsTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdChainsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdChainsFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdChainsSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdChainsSession struct {
+	Contract     *StdChains        // 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
+}
+
+// StdChainsCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdChainsCallerSession struct {
+	Contract *StdChainsCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts    // Call options to use throughout this session
+}
+
+// StdChainsTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdChainsTransactorSession struct {
+	Contract     *StdChainsTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
+}
+
+// StdChainsRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdChainsRaw struct {
+	Contract *StdChains // Generic contract binding to access the raw methods on
+}
+
+// StdChainsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdChainsCallerRaw struct {
+	Contract *StdChainsCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdChainsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdChainsTransactorRaw struct {
+	Contract *StdChainsTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdChains creates a new instance of StdChains, bound to a specific deployed contract.
+func NewStdChains(address common.Address, backend bind.ContractBackend) (*StdChains, error) {
+	contract, err := bindStdChains(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdChains{StdChainsCaller: StdChainsCaller{contract: contract}, StdChainsTransactor: StdChainsTransactor{contract: contract}, StdChainsFilterer: StdChainsFilterer{contract: contract}}, nil
+}
+
+// NewStdChainsCaller creates a new read-only instance of StdChains, bound to a specific deployed contract.
+func NewStdChainsCaller(address common.Address, caller bind.ContractCaller) (*StdChainsCaller, error) {
+	contract, err := bindStdChains(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdChainsCaller{contract: contract}, nil
+}
+
+// NewStdChainsTransactor creates a new write-only instance of StdChains, bound to a specific deployed contract.
+func NewStdChainsTransactor(address common.Address, transactor bind.ContractTransactor) (*StdChainsTransactor, error) {
+	contract, err := bindStdChains(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdChainsTransactor{contract: contract}, nil
+}
+
+// NewStdChainsFilterer creates a new log filterer instance of StdChains, bound to a specific deployed contract.
+func NewStdChainsFilterer(address common.Address, filterer bind.ContractFilterer) (*StdChainsFilterer, error) {
+	contract, err := bindStdChains(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdChainsFilterer{contract: contract}, nil
+}
+
+// bindStdChains binds a generic wrapper to an already deployed contract.
+func bindStdChains(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdChainsMetaData.GetAbi()
+	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 (_StdChains *StdChainsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdChains.Contract.StdChainsCaller.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 (_StdChains *StdChainsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdChains.Contract.StdChainsTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdChains *StdChainsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdChains.Contract.StdChainsTransactor.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 (_StdChains *StdChainsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdChains.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 (_StdChains *StdChainsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdChains.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdChains *StdChainsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdChains.Contract.contract.Transact(opts, method, params...)
+}
+
+// StdCheatsMetaData contains all meta data concerning the StdCheats contract.
+var StdCheatsMetaData = &bind.MetaData{
+	ABI: "[]",
+}
+
+// StdCheatsABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdCheatsMetaData.ABI instead.
+var StdCheatsABI = StdCheatsMetaData.ABI
+
+// StdCheats is an auto generated Go binding around an Ethereum contract.
+type StdCheats struct {
+	StdCheatsCaller     // Read-only binding to the contract
+	StdCheatsTransactor // Write-only binding to the contract
+	StdCheatsFilterer   // Log filterer for contract events
+}
+
+// StdCheatsCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdCheatsCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdCheatsTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdCheatsTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdCheatsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdCheatsFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdCheatsSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdCheatsSession struct {
+	Contract     *StdCheats        // 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
+}
+
+// StdCheatsCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdCheatsCallerSession struct {
+	Contract *StdCheatsCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts    // Call options to use throughout this session
+}
+
+// StdCheatsTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdCheatsTransactorSession struct {
+	Contract     *StdCheatsTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
+}
+
+// StdCheatsRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdCheatsRaw struct {
+	Contract *StdCheats // Generic contract binding to access the raw methods on
+}
+
+// StdCheatsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdCheatsCallerRaw struct {
+	Contract *StdCheatsCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdCheatsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdCheatsTransactorRaw struct {
+	Contract *StdCheatsTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdCheats creates a new instance of StdCheats, bound to a specific deployed contract.
+func NewStdCheats(address common.Address, backend bind.ContractBackend) (*StdCheats, error) {
+	contract, err := bindStdCheats(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdCheats{StdCheatsCaller: StdCheatsCaller{contract: contract}, StdCheatsTransactor: StdCheatsTransactor{contract: contract}, StdCheatsFilterer: StdCheatsFilterer{contract: contract}}, nil
+}
+
+// NewStdCheatsCaller creates a new read-only instance of StdCheats, bound to a specific deployed contract.
+func NewStdCheatsCaller(address common.Address, caller bind.ContractCaller) (*StdCheatsCaller, error) {
+	contract, err := bindStdCheats(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdCheatsCaller{contract: contract}, nil
+}
+
+// NewStdCheatsTransactor creates a new write-only instance of StdCheats, bound to a specific deployed contract.
+func NewStdCheatsTransactor(address common.Address, transactor bind.ContractTransactor) (*StdCheatsTransactor, error) {
+	contract, err := bindStdCheats(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdCheatsTransactor{contract: contract}, nil
+}
+
+// NewStdCheatsFilterer creates a new log filterer instance of StdCheats, bound to a specific deployed contract.
+func NewStdCheatsFilterer(address common.Address, filterer bind.ContractFilterer) (*StdCheatsFilterer, error) {
+	contract, err := bindStdCheats(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdCheatsFilterer{contract: contract}, nil
+}
+
+// bindStdCheats binds a generic wrapper to an already deployed contract.
+func bindStdCheats(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdCheatsMetaData.GetAbi()
+	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 (_StdCheats *StdCheatsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdCheats.Contract.StdCheatsCaller.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 (_StdCheats *StdCheatsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdCheats.Contract.StdCheatsTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdCheats *StdCheatsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdCheats.Contract.StdCheatsTransactor.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 (_StdCheats *StdCheatsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdCheats.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 (_StdCheats *StdCheatsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdCheats.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdCheats *StdCheatsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdCheats.Contract.contract.Transact(opts, method, params...)
+}
+
+// StdCheatsSafeMetaData contains all meta data concerning the StdCheatsSafe contract.
+var StdCheatsSafeMetaData = &bind.MetaData{
+	ABI: "[]",
+}
+
+// StdCheatsSafeABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdCheatsSafeMetaData.ABI instead.
+var StdCheatsSafeABI = StdCheatsSafeMetaData.ABI
+
+// StdCheatsSafe is an auto generated Go binding around an Ethereum contract.
+type StdCheatsSafe struct {
+	StdCheatsSafeCaller     // Read-only binding to the contract
+	StdCheatsSafeTransactor // Write-only binding to the contract
+	StdCheatsSafeFilterer   // Log filterer for contract events
+}
+
+// StdCheatsSafeCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdCheatsSafeCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdCheatsSafeTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdCheatsSafeTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdCheatsSafeFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdCheatsSafeFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdCheatsSafeSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdCheatsSafeSession struct {
+	Contract     *StdCheatsSafe    // 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
+}
+
+// StdCheatsSafeCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdCheatsSafeCallerSession struct {
+	Contract *StdCheatsSafeCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts        // Call options to use throughout this session
+}
+
+// StdCheatsSafeTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdCheatsSafeTransactorSession struct {
+	Contract     *StdCheatsSafeTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
+}
+
+// StdCheatsSafeRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdCheatsSafeRaw struct {
+	Contract *StdCheatsSafe // Generic contract binding to access the raw methods on
+}
+
+// StdCheatsSafeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdCheatsSafeCallerRaw struct {
+	Contract *StdCheatsSafeCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdCheatsSafeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdCheatsSafeTransactorRaw struct {
+	Contract *StdCheatsSafeTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdCheatsSafe creates a new instance of StdCheatsSafe, bound to a specific deployed contract.
+func NewStdCheatsSafe(address common.Address, backend bind.ContractBackend) (*StdCheatsSafe, error) {
+	contract, err := bindStdCheatsSafe(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdCheatsSafe{StdCheatsSafeCaller: StdCheatsSafeCaller{contract: contract}, StdCheatsSafeTransactor: StdCheatsSafeTransactor{contract: contract}, StdCheatsSafeFilterer: StdCheatsSafeFilterer{contract: contract}}, nil
+}
+
+// NewStdCheatsSafeCaller creates a new read-only instance of StdCheatsSafe, bound to a specific deployed contract.
+func NewStdCheatsSafeCaller(address common.Address, caller bind.ContractCaller) (*StdCheatsSafeCaller, error) {
+	contract, err := bindStdCheatsSafe(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdCheatsSafeCaller{contract: contract}, nil
+}
+
+// NewStdCheatsSafeTransactor creates a new write-only instance of StdCheatsSafe, bound to a specific deployed contract.
+func NewStdCheatsSafeTransactor(address common.Address, transactor bind.ContractTransactor) (*StdCheatsSafeTransactor, error) {
+	contract, err := bindStdCheatsSafe(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdCheatsSafeTransactor{contract: contract}, nil
+}
+
+// NewStdCheatsSafeFilterer creates a new log filterer instance of StdCheatsSafe, bound to a specific deployed contract.
+func NewStdCheatsSafeFilterer(address common.Address, filterer bind.ContractFilterer) (*StdCheatsSafeFilterer, error) {
+	contract, err := bindStdCheatsSafe(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdCheatsSafeFilterer{contract: contract}, nil
+}
+
+// bindStdCheatsSafe binds a generic wrapper to an already deployed contract.
+func bindStdCheatsSafe(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdCheatsSafeMetaData.GetAbi()
+	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 (_StdCheatsSafe *StdCheatsSafeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdCheatsSafe.Contract.StdCheatsSafeCaller.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 (_StdCheatsSafe *StdCheatsSafeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdCheatsSafe.Contract.StdCheatsSafeTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdCheatsSafe *StdCheatsSafeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdCheatsSafe.Contract.StdCheatsSafeTransactor.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 (_StdCheatsSafe *StdCheatsSafeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdCheatsSafe.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 (_StdCheatsSafe *StdCheatsSafeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdCheatsSafe.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdCheatsSafe *StdCheatsSafeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdCheatsSafe.Contract.contract.Transact(opts, method, params...)
+}
+
+// StdConstantsMetaData contains all meta data concerning the StdConstants contract.
+var StdConstantsMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220dcfd21f53d980abcfc1cce2289578a13ab760a8a08af0ee3202e89ee85ea2d7c64736f6c63430008190033",
+}
+
+// StdConstantsABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdConstantsMetaData.ABI instead.
+var StdConstantsABI = StdConstantsMetaData.ABI
+
+// StdConstantsBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use StdConstantsMetaData.Bin instead.
+var StdConstantsBin = StdConstantsMetaData.Bin
+
+// DeployStdConstants deploys a new Ethereum contract, binding an instance of StdConstants to it.
+func DeployStdConstants(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdConstants, error) {
+	parsed, err := StdConstantsMetaData.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(StdConstantsBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &StdConstants{StdConstantsCaller: StdConstantsCaller{contract: contract}, StdConstantsTransactor: StdConstantsTransactor{contract: contract}, StdConstantsFilterer: StdConstantsFilterer{contract: contract}}, nil
+}
+
+// StdConstants is an auto generated Go binding around an Ethereum contract.
+type StdConstants struct {
+	StdConstantsCaller     // Read-only binding to the contract
+	StdConstantsTransactor // Write-only binding to the contract
+	StdConstantsFilterer   // Log filterer for contract events
+}
+
+// StdConstantsCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdConstantsCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdConstantsTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdConstantsTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdConstantsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdConstantsFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdConstantsSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdConstantsSession struct {
+	Contract     *StdConstants     // 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
+}
+
+// StdConstantsCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdConstantsCallerSession struct {
+	Contract *StdConstantsCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts       // Call options to use throughout this session
+}
+
+// StdConstantsTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdConstantsTransactorSession struct {
+	Contract     *StdConstantsTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
+}
+
+// StdConstantsRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdConstantsRaw struct {
+	Contract *StdConstants // Generic contract binding to access the raw methods on
+}
+
+// StdConstantsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdConstantsCallerRaw struct {
+	Contract *StdConstantsCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdConstantsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdConstantsTransactorRaw struct {
+	Contract *StdConstantsTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdConstants creates a new instance of StdConstants, bound to a specific deployed contract.
+func NewStdConstants(address common.Address, backend bind.ContractBackend) (*StdConstants, error) {
+	contract, err := bindStdConstants(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdConstants{StdConstantsCaller: StdConstantsCaller{contract: contract}, StdConstantsTransactor: StdConstantsTransactor{contract: contract}, StdConstantsFilterer: StdConstantsFilterer{contract: contract}}, nil
+}
+
+// NewStdConstantsCaller creates a new read-only instance of StdConstants, bound to a specific deployed contract.
+func NewStdConstantsCaller(address common.Address, caller bind.ContractCaller) (*StdConstantsCaller, error) {
+	contract, err := bindStdConstants(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdConstantsCaller{contract: contract}, nil
+}
+
+// NewStdConstantsTransactor creates a new write-only instance of StdConstants, bound to a specific deployed contract.
+func NewStdConstantsTransactor(address common.Address, transactor bind.ContractTransactor) (*StdConstantsTransactor, error) {
+	contract, err := bindStdConstants(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdConstantsTransactor{contract: contract}, nil
+}
+
+// NewStdConstantsFilterer creates a new log filterer instance of StdConstants, bound to a specific deployed contract.
+func NewStdConstantsFilterer(address common.Address, filterer bind.ContractFilterer) (*StdConstantsFilterer, error) {
+	contract, err := bindStdConstants(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdConstantsFilterer{contract: contract}, nil
+}
+
+// bindStdConstants binds a generic wrapper to an already deployed contract.
+func bindStdConstants(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdConstantsMetaData.GetAbi()
+	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 (_StdConstants *StdConstantsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdConstants.Contract.StdConstantsCaller.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 (_StdConstants *StdConstantsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdConstants.Contract.StdConstantsTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdConstants *StdConstantsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdConstants.Contract.StdConstantsTransactor.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 (_StdConstants *StdConstantsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdConstants.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 (_StdConstants *StdConstantsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdConstants.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdConstants *StdConstantsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdConstants.Contract.contract.Transact(opts, method, params...)
+}
+
+// StdInvariantMetaData contains all meta data concerning the StdInvariant contract.
+var StdInvariantMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+}
+
+// StdInvariantABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdInvariantMetaData.ABI instead.
+var StdInvariantABI = StdInvariantMetaData.ABI
+
+// StdInvariant is an auto generated Go binding around an Ethereum contract.
+type StdInvariant struct {
+	StdInvariantCaller     // Read-only binding to the contract
+	StdInvariantTransactor // Write-only binding to the contract
+	StdInvariantFilterer   // Log filterer for contract events
+}
+
+// StdInvariantCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdInvariantCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdInvariantTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdInvariantTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdInvariantFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdInvariantFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdInvariantSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdInvariantSession struct {
+	Contract     *StdInvariant     // 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
+}
+
+// StdInvariantCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdInvariantCallerSession struct {
+	Contract *StdInvariantCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts       // Call options to use throughout this session
+}
+
+// StdInvariantTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdInvariantTransactorSession struct {
+	Contract     *StdInvariantTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
+}
+
+// StdInvariantRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdInvariantRaw struct {
+	Contract *StdInvariant // Generic contract binding to access the raw methods on
+}
+
+// StdInvariantCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdInvariantCallerRaw struct {
+	Contract *StdInvariantCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdInvariantTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdInvariantTransactorRaw struct {
+	Contract *StdInvariantTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdInvariant creates a new instance of StdInvariant, bound to a specific deployed contract.
+func NewStdInvariant(address common.Address, backend bind.ContractBackend) (*StdInvariant, error) {
+	contract, err := bindStdInvariant(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdInvariant{StdInvariantCaller: StdInvariantCaller{contract: contract}, StdInvariantTransactor: StdInvariantTransactor{contract: contract}, StdInvariantFilterer: StdInvariantFilterer{contract: contract}}, nil
+}
+
+// NewStdInvariantCaller creates a new read-only instance of StdInvariant, bound to a specific deployed contract.
+func NewStdInvariantCaller(address common.Address, caller bind.ContractCaller) (*StdInvariantCaller, error) {
+	contract, err := bindStdInvariant(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdInvariantCaller{contract: contract}, nil
+}
+
+// NewStdInvariantTransactor creates a new write-only instance of StdInvariant, bound to a specific deployed contract.
+func NewStdInvariantTransactor(address common.Address, transactor bind.ContractTransactor) (*StdInvariantTransactor, error) {
+	contract, err := bindStdInvariant(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdInvariantTransactor{contract: contract}, nil
+}
+
+// NewStdInvariantFilterer creates a new log filterer instance of StdInvariant, bound to a specific deployed contract.
+func NewStdInvariantFilterer(address common.Address, filterer bind.ContractFilterer) (*StdInvariantFilterer, error) {
+	contract, err := bindStdInvariant(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdInvariantFilterer{contract: contract}, nil
+}
+
+// bindStdInvariant binds a generic wrapper to an already deployed contract.
+func bindStdInvariant(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdInvariantMetaData.GetAbi()
+	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 (_StdInvariant *StdInvariantRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdInvariant.Contract.StdInvariantCaller.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 (_StdInvariant *StdInvariantRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdInvariant.Contract.StdInvariantTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdInvariant *StdInvariantRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdInvariant.Contract.StdInvariantTransactor.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 (_StdInvariant *StdInvariantCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdInvariant.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 (_StdInvariant *StdInvariantTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdInvariant.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdInvariant *StdInvariantTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdInvariant.Contract.contract.Transact(opts, method, params...)
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_StdInvariant *StdInvariantCaller) ExcludeArtifacts(opts *bind.CallOpts) ([]string, error) {
+	var out []interface{}
+	err := _StdInvariant.contract.Call(opts, &out, "excludeArtifacts")
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_StdInvariant *StdInvariantSession) ExcludeArtifacts() ([]string, error) {
+	return _StdInvariant.Contract.ExcludeArtifacts(&_StdInvariant.CallOpts)
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_StdInvariant *StdInvariantCallerSession) ExcludeArtifacts() ([]string, error) {
+	return _StdInvariant.Contract.ExcludeArtifacts(&_StdInvariant.CallOpts)
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_StdInvariant *StdInvariantCaller) ExcludeContracts(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _StdInvariant.contract.Call(opts, &out, "excludeContracts")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_StdInvariant *StdInvariantSession) ExcludeContracts() ([]common.Address, error) {
+	return _StdInvariant.Contract.ExcludeContracts(&_StdInvariant.CallOpts)
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_StdInvariant *StdInvariantCallerSession) ExcludeContracts() ([]common.Address, error) {
+	return _StdInvariant.Contract.ExcludeContracts(&_StdInvariant.CallOpts)
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_StdInvariant *StdInvariantCaller) ExcludeSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) {
+	var out []interface{}
+	err := _StdInvariant.contract.Call(opts, &out, "excludeSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector)
+
+	return out0, err
+
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_StdInvariant *StdInvariantSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _StdInvariant.Contract.ExcludeSelectors(&_StdInvariant.CallOpts)
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_StdInvariant *StdInvariantCallerSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _StdInvariant.Contract.ExcludeSelectors(&_StdInvariant.CallOpts)
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_StdInvariant *StdInvariantCaller) ExcludeSenders(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _StdInvariant.contract.Call(opts, &out, "excludeSenders")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_StdInvariant *StdInvariantSession) ExcludeSenders() ([]common.Address, error) {
+	return _StdInvariant.Contract.ExcludeSenders(&_StdInvariant.CallOpts)
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_StdInvariant *StdInvariantCallerSession) ExcludeSenders() ([]common.Address, error) {
+	return _StdInvariant.Contract.ExcludeSenders(&_StdInvariant.CallOpts)
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_StdInvariant *StdInvariantCaller) TargetArtifactSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzArtifactSelector, error) {
+	var out []interface{}
+	err := _StdInvariant.contract.Call(opts, &out, "targetArtifactSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzArtifactSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzArtifactSelector)).(*[]StdInvariantFuzzArtifactSelector)
+
+	return out0, err
+
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_StdInvariant *StdInvariantSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) {
+	return _StdInvariant.Contract.TargetArtifactSelectors(&_StdInvariant.CallOpts)
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_StdInvariant *StdInvariantCallerSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) {
+	return _StdInvariant.Contract.TargetArtifactSelectors(&_StdInvariant.CallOpts)
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_StdInvariant *StdInvariantCaller) TargetArtifacts(opts *bind.CallOpts) ([]string, error) {
+	var out []interface{}
+	err := _StdInvariant.contract.Call(opts, &out, "targetArtifacts")
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_StdInvariant *StdInvariantSession) TargetArtifacts() ([]string, error) {
+	return _StdInvariant.Contract.TargetArtifacts(&_StdInvariant.CallOpts)
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_StdInvariant *StdInvariantCallerSession) TargetArtifacts() ([]string, error) {
+	return _StdInvariant.Contract.TargetArtifacts(&_StdInvariant.CallOpts)
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_StdInvariant *StdInvariantCaller) TargetContracts(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _StdInvariant.contract.Call(opts, &out, "targetContracts")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_StdInvariant *StdInvariantSession) TargetContracts() ([]common.Address, error) {
+	return _StdInvariant.Contract.TargetContracts(&_StdInvariant.CallOpts)
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_StdInvariant *StdInvariantCallerSession) TargetContracts() ([]common.Address, error) {
+	return _StdInvariant.Contract.TargetContracts(&_StdInvariant.CallOpts)
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_StdInvariant *StdInvariantCaller) TargetInterfaces(opts *bind.CallOpts) ([]StdInvariantFuzzInterface, error) {
+	var out []interface{}
+	err := _StdInvariant.contract.Call(opts, &out, "targetInterfaces")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzInterface), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzInterface)).(*[]StdInvariantFuzzInterface)
+
+	return out0, err
+
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_StdInvariant *StdInvariantSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) {
+	return _StdInvariant.Contract.TargetInterfaces(&_StdInvariant.CallOpts)
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_StdInvariant *StdInvariantCallerSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) {
+	return _StdInvariant.Contract.TargetInterfaces(&_StdInvariant.CallOpts)
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_StdInvariant *StdInvariantCaller) TargetSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) {
+	var out []interface{}
+	err := _StdInvariant.contract.Call(opts, &out, "targetSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector)
+
+	return out0, err
+
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_StdInvariant *StdInvariantSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _StdInvariant.Contract.TargetSelectors(&_StdInvariant.CallOpts)
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_StdInvariant *StdInvariantCallerSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _StdInvariant.Contract.TargetSelectors(&_StdInvariant.CallOpts)
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_StdInvariant *StdInvariantCaller) TargetSenders(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _StdInvariant.contract.Call(opts, &out, "targetSenders")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_StdInvariant *StdInvariantSession) TargetSenders() ([]common.Address, error) {
+	return _StdInvariant.Contract.TargetSenders(&_StdInvariant.CallOpts)
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_StdInvariant *StdInvariantCallerSession) TargetSenders() ([]common.Address, error) {
+	return _StdInvariant.Contract.TargetSenders(&_StdInvariant.CallOpts)
+}
+
+// StdStyleMetaData contains all meta data concerning the StdStyle contract.
+var StdStyleMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea264697066735822122059b8e95768cade2a7dbc088c11221d543c4fcf96c6b09f632d3bafe34327d12b64736f6c63430008190033",
+}
+
+// StdStyleABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdStyleMetaData.ABI instead.
+var StdStyleABI = StdStyleMetaData.ABI
+
+// StdStyleBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use StdStyleMetaData.Bin instead.
+var StdStyleBin = StdStyleMetaData.Bin
+
+// DeployStdStyle deploys a new Ethereum contract, binding an instance of StdStyle to it.
+func DeployStdStyle(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdStyle, error) {
+	parsed, err := StdStyleMetaData.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(StdStyleBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &StdStyle{StdStyleCaller: StdStyleCaller{contract: contract}, StdStyleTransactor: StdStyleTransactor{contract: contract}, StdStyleFilterer: StdStyleFilterer{contract: contract}}, nil
+}
+
+// StdStyle is an auto generated Go binding around an Ethereum contract.
+type StdStyle struct {
+	StdStyleCaller     // Read-only binding to the contract
+	StdStyleTransactor // Write-only binding to the contract
+	StdStyleFilterer   // Log filterer for contract events
+}
+
+// StdStyleCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdStyleCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdStyleTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdStyleTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdStyleFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdStyleFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdStyleSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdStyleSession struct {
+	Contract     *StdStyle         // 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
+}
+
+// StdStyleCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdStyleCallerSession struct {
+	Contract *StdStyleCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts   // Call options to use throughout this session
+}
+
+// StdStyleTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdStyleTransactorSession struct {
+	Contract     *StdStyleTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
+}
+
+// StdStyleRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdStyleRaw struct {
+	Contract *StdStyle // Generic contract binding to access the raw methods on
+}
+
+// StdStyleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdStyleCallerRaw struct {
+	Contract *StdStyleCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdStyleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdStyleTransactorRaw struct {
+	Contract *StdStyleTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdStyle creates a new instance of StdStyle, bound to a specific deployed contract.
+func NewStdStyle(address common.Address, backend bind.ContractBackend) (*StdStyle, error) {
+	contract, err := bindStdStyle(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdStyle{StdStyleCaller: StdStyleCaller{contract: contract}, StdStyleTransactor: StdStyleTransactor{contract: contract}, StdStyleFilterer: StdStyleFilterer{contract: contract}}, nil
+}
+
+// NewStdStyleCaller creates a new read-only instance of StdStyle, bound to a specific deployed contract.
+func NewStdStyleCaller(address common.Address, caller bind.ContractCaller) (*StdStyleCaller, error) {
+	contract, err := bindStdStyle(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdStyleCaller{contract: contract}, nil
+}
+
+// NewStdStyleTransactor creates a new write-only instance of StdStyle, bound to a specific deployed contract.
+func NewStdStyleTransactor(address common.Address, transactor bind.ContractTransactor) (*StdStyleTransactor, error) {
+	contract, err := bindStdStyle(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdStyleTransactor{contract: contract}, nil
+}
+
+// NewStdStyleFilterer creates a new log filterer instance of StdStyle, bound to a specific deployed contract.
+func NewStdStyleFilterer(address common.Address, filterer bind.ContractFilterer) (*StdStyleFilterer, error) {
+	contract, err := bindStdStyle(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdStyleFilterer{contract: contract}, nil
+}
+
+// bindStdStyle binds a generic wrapper to an already deployed contract.
+func bindStdStyle(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdStyleMetaData.GetAbi()
+	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 (_StdStyle *StdStyleRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdStyle.Contract.StdStyleCaller.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 (_StdStyle *StdStyleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdStyle.Contract.StdStyleTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdStyle *StdStyleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdStyle.Contract.StdStyleTransactor.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 (_StdStyle *StdStyleCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdStyle.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 (_StdStyle *StdStyleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdStyle.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdStyle *StdStyleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdStyle.Contract.contract.Transact(opts, method, params...)
+}
+
+// StdUtilsMetaData contains all meta data concerning the StdUtils contract.
+var StdUtilsMetaData = &bind.MetaData{
+	ABI: "[]",
+}
+
+// StdUtilsABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdUtilsMetaData.ABI instead.
+var StdUtilsABI = StdUtilsMetaData.ABI
+
+// StdUtils is an auto generated Go binding around an Ethereum contract.
+type StdUtils struct {
+	StdUtilsCaller     // Read-only binding to the contract
+	StdUtilsTransactor // Write-only binding to the contract
+	StdUtilsFilterer   // Log filterer for contract events
+}
+
+// StdUtilsCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdUtilsCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdUtilsTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdUtilsTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdUtilsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdUtilsFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdUtilsSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdUtilsSession struct {
+	Contract     *StdUtils         // 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
+}
+
+// StdUtilsCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdUtilsCallerSession struct {
+	Contract *StdUtilsCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts   // Call options to use throughout this session
+}
+
+// StdUtilsTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdUtilsTransactorSession struct {
+	Contract     *StdUtilsTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
+}
+
+// StdUtilsRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdUtilsRaw struct {
+	Contract *StdUtils // Generic contract binding to access the raw methods on
+}
+
+// StdUtilsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdUtilsCallerRaw struct {
+	Contract *StdUtilsCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdUtilsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdUtilsTransactorRaw struct {
+	Contract *StdUtilsTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdUtils creates a new instance of StdUtils, bound to a specific deployed contract.
+func NewStdUtils(address common.Address, backend bind.ContractBackend) (*StdUtils, error) {
+	contract, err := bindStdUtils(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdUtils{StdUtilsCaller: StdUtilsCaller{contract: contract}, StdUtilsTransactor: StdUtilsTransactor{contract: contract}, StdUtilsFilterer: StdUtilsFilterer{contract: contract}}, nil
+}
+
+// NewStdUtilsCaller creates a new read-only instance of StdUtils, bound to a specific deployed contract.
+func NewStdUtilsCaller(address common.Address, caller bind.ContractCaller) (*StdUtilsCaller, error) {
+	contract, err := bindStdUtils(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdUtilsCaller{contract: contract}, nil
+}
+
+// NewStdUtilsTransactor creates a new write-only instance of StdUtils, bound to a specific deployed contract.
+func NewStdUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*StdUtilsTransactor, error) {
+	contract, err := bindStdUtils(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdUtilsTransactor{contract: contract}, nil
+}
+
+// NewStdUtilsFilterer creates a new log filterer instance of StdUtils, bound to a specific deployed contract.
+func NewStdUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*StdUtilsFilterer, error) {
+	contract, err := bindStdUtils(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdUtilsFilterer{contract: contract}, nil
+}
+
+// bindStdUtils binds a generic wrapper to an already deployed contract.
+func bindStdUtils(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdUtilsMetaData.GetAbi()
+	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 (_StdUtils *StdUtilsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdUtils.Contract.StdUtilsCaller.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 (_StdUtils *StdUtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdUtils.Contract.StdUtilsTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdUtils *StdUtilsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdUtils.Contract.StdUtilsTransactor.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 (_StdUtils *StdUtilsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdUtils.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 (_StdUtils *StdUtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdUtils.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdUtils *StdUtilsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdUtils.Contract.contract.Transact(opts, method, params...)
+}
+
+// StringsMetaData contains all meta data concerning the Strings contract.
+var StringsMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212206abb0aff4561ae6e828a7a039c991bd16ed0bcacc49d349f92452b0215fc67cf64736f6c63430008190033",
+}
+
+// StringsABI is the input ABI used to generate the binding from.
+// Deprecated: Use StringsMetaData.ABI instead.
+var StringsABI = StringsMetaData.ABI
+
+// StringsBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use StringsMetaData.Bin instead.
+var StringsBin = StringsMetaData.Bin
+
+// DeployStrings deploys a new Ethereum contract, binding an instance of Strings to it.
+func DeployStrings(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Strings, error) {
+	parsed, err := StringsMetaData.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(StringsBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &Strings{StringsCaller: StringsCaller{contract: contract}, StringsTransactor: StringsTransactor{contract: contract}, StringsFilterer: StringsFilterer{contract: contract}}, nil
+}
+
+// Strings is an auto generated Go binding around an Ethereum contract.
+type Strings struct {
+	StringsCaller     // Read-only binding to the contract
+	StringsTransactor // Write-only binding to the contract
+	StringsFilterer   // Log filterer for contract events
+}
+
+// StringsCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StringsCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StringsTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StringsTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StringsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StringsFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StringsSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StringsSession struct {
+	Contract     *Strings          // 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
+}
+
+// StringsCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StringsCallerSession struct {
+	Contract *StringsCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts  // Call options to use throughout this session
+}
+
+// StringsTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StringsTransactorSession struct {
+	Contract     *StringsTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
+}
+
+// StringsRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StringsRaw struct {
+	Contract *Strings // Generic contract binding to access the raw methods on
+}
+
+// StringsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StringsCallerRaw struct {
+	Contract *StringsCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StringsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StringsTransactorRaw struct {
+	Contract *StringsTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStrings creates a new instance of Strings, bound to a specific deployed contract.
+func NewStrings(address common.Address, backend bind.ContractBackend) (*Strings, error) {
+	contract, err := bindStrings(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Strings{StringsCaller: StringsCaller{contract: contract}, StringsTransactor: StringsTransactor{contract: contract}, StringsFilterer: StringsFilterer{contract: contract}}, nil
+}
+
+// NewStringsCaller creates a new read-only instance of Strings, bound to a specific deployed contract.
+func NewStringsCaller(address common.Address, caller bind.ContractCaller) (*StringsCaller, error) {
+	contract, err := bindStrings(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StringsCaller{contract: contract}, nil
+}
+
+// NewStringsTransactor creates a new write-only instance of Strings, bound to a specific deployed contract.
+func NewStringsTransactor(address common.Address, transactor bind.ContractTransactor) (*StringsTransactor, error) {
+	contract, err := bindStrings(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StringsTransactor{contract: contract}, nil
+}
+
+// NewStringsFilterer creates a new log filterer instance of Strings, bound to a specific deployed contract.
+func NewStringsFilterer(address common.Address, filterer bind.ContractFilterer) (*StringsFilterer, error) {
+	contract, err := bindStrings(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StringsFilterer{contract: contract}, nil
+}
+
+// bindStrings binds a generic wrapper to an already deployed contract.
+func bindStrings(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StringsMetaData.GetAbi()
+	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 (_Strings *StringsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Strings.Contract.StringsCaller.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 (_Strings *StringsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Strings.Contract.StringsTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Strings *StringsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Strings.Contract.StringsTransactor.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 (_Strings *StringsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Strings.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 (_Strings *StringsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Strings.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Strings *StringsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Strings.Contract.contract.Transact(opts, method, params...)
+}
+
+// TCBInfoV2BaseMetaData contains all meta data concerning the TCBInfoV2Base contract.
+var TCBInfoV2BaseMetaData = &bind.MetaData{
+	ABI: "[]",
+}
+
+// TCBInfoV2BaseABI is the input ABI used to generate the binding from.
+// Deprecated: Use TCBInfoV2BaseMetaData.ABI instead.
+var TCBInfoV2BaseABI = TCBInfoV2BaseMetaData.ABI
+
+// TCBInfoV2Base is an auto generated Go binding around an Ethereum contract.
+type TCBInfoV2Base struct {
+	TCBInfoV2BaseCaller     // Read-only binding to the contract
+	TCBInfoV2BaseTransactor // Write-only binding to the contract
+	TCBInfoV2BaseFilterer   // Log filterer for contract events
+}
+
+// TCBInfoV2BaseCaller is an auto generated read-only Go binding around an Ethereum contract.
+type TCBInfoV2BaseCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// TCBInfoV2BaseTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type TCBInfoV2BaseTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// TCBInfoV2BaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type TCBInfoV2BaseFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// TCBInfoV2BaseSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type TCBInfoV2BaseSession struct {
+	Contract     *TCBInfoV2Base    // 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
+}
+
+// TCBInfoV2BaseCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type TCBInfoV2BaseCallerSession struct {
+	Contract *TCBInfoV2BaseCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts        // Call options to use throughout this session
+}
+
+// TCBInfoV2BaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type TCBInfoV2BaseTransactorSession struct {
+	Contract     *TCBInfoV2BaseTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
+}
+
+// TCBInfoV2BaseRaw is an auto generated low-level Go binding around an Ethereum contract.
+type TCBInfoV2BaseRaw struct {
+	Contract *TCBInfoV2Base // Generic contract binding to access the raw methods on
+}
+
+// TCBInfoV2BaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type TCBInfoV2BaseCallerRaw struct {
+	Contract *TCBInfoV2BaseCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// TCBInfoV2BaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type TCBInfoV2BaseTransactorRaw struct {
+	Contract *TCBInfoV2BaseTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewTCBInfoV2Base creates a new instance of TCBInfoV2Base, bound to a specific deployed contract.
+func NewTCBInfoV2Base(address common.Address, backend bind.ContractBackend) (*TCBInfoV2Base, error) {
+	contract, err := bindTCBInfoV2Base(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &TCBInfoV2Base{TCBInfoV2BaseCaller: TCBInfoV2BaseCaller{contract: contract}, TCBInfoV2BaseTransactor: TCBInfoV2BaseTransactor{contract: contract}, TCBInfoV2BaseFilterer: TCBInfoV2BaseFilterer{contract: contract}}, nil
+}
+
+// NewTCBInfoV2BaseCaller creates a new read-only instance of TCBInfoV2Base, bound to a specific deployed contract.
+func NewTCBInfoV2BaseCaller(address common.Address, caller bind.ContractCaller) (*TCBInfoV2BaseCaller, error) {
+	contract, err := bindTCBInfoV2Base(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &TCBInfoV2BaseCaller{contract: contract}, nil
+}
+
+// NewTCBInfoV2BaseTransactor creates a new write-only instance of TCBInfoV2Base, bound to a specific deployed contract.
+func NewTCBInfoV2BaseTransactor(address common.Address, transactor bind.ContractTransactor) (*TCBInfoV2BaseTransactor, error) {
+	contract, err := bindTCBInfoV2Base(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &TCBInfoV2BaseTransactor{contract: contract}, nil
+}
+
+// NewTCBInfoV2BaseFilterer creates a new log filterer instance of TCBInfoV2Base, bound to a specific deployed contract.
+func NewTCBInfoV2BaseFilterer(address common.Address, filterer bind.ContractFilterer) (*TCBInfoV2BaseFilterer, error) {
+	contract, err := bindTCBInfoV2Base(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &TCBInfoV2BaseFilterer{contract: contract}, nil
+}
+
+// bindTCBInfoV2Base binds a generic wrapper to an already deployed contract.
+func bindTCBInfoV2Base(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := TCBInfoV2BaseMetaData.GetAbi()
+	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 (_TCBInfoV2Base *TCBInfoV2BaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _TCBInfoV2Base.Contract.TCBInfoV2BaseCaller.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 (_TCBInfoV2Base *TCBInfoV2BaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _TCBInfoV2Base.Contract.TCBInfoV2BaseTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_TCBInfoV2Base *TCBInfoV2BaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _TCBInfoV2Base.Contract.TCBInfoV2BaseTransactor.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 (_TCBInfoV2Base *TCBInfoV2BaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _TCBInfoV2Base.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 (_TCBInfoV2Base *TCBInfoV2BaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _TCBInfoV2Base.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_TCBInfoV2Base *TCBInfoV2BaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _TCBInfoV2Base.Contract.contract.Transact(opts, method, params...)
+}
+
+// TestMetaData contains all meta data concerning the Test contract.
+var TestMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"}]",
+}
+
+// TestABI is the input ABI used to generate the binding from.
+// Deprecated: Use TestMetaData.ABI instead.
+var TestABI = TestMetaData.ABI
+
+// Test is an auto generated Go binding around an Ethereum contract.
+type Test struct {
+	TestCaller     // Read-only binding to the contract
+	TestTransactor // Write-only binding to the contract
+	TestFilterer   // Log filterer for contract events
+}
+
+// TestCaller is an auto generated read-only Go binding around an Ethereum contract.
+type TestCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// TestTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type TestTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// TestFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type TestFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// TestSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type TestSession struct {
+	Contract     *Test             // 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
+}
+
+// TestCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type TestCallerSession struct {
+	Contract *TestCaller   // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts // Call options to use throughout this session
+}
+
+// TestTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type TestTransactorSession struct {
+	Contract     *TestTransactor   // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// TestRaw is an auto generated low-level Go binding around an Ethereum contract.
+type TestRaw struct {
+	Contract *Test // Generic contract binding to access the raw methods on
+}
+
+// TestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type TestCallerRaw struct {
+	Contract *TestCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// TestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type TestTransactorRaw struct {
+	Contract *TestTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewTest creates a new instance of Test, bound to a specific deployed contract.
+func NewTest(address common.Address, backend bind.ContractBackend) (*Test, error) {
+	contract, err := bindTest(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Test{TestCaller: TestCaller{contract: contract}, TestTransactor: TestTransactor{contract: contract}, TestFilterer: TestFilterer{contract: contract}}, nil
+}
+
+// NewTestCaller creates a new read-only instance of Test, bound to a specific deployed contract.
+func NewTestCaller(address common.Address, caller bind.ContractCaller) (*TestCaller, error) {
+	contract, err := bindTest(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &TestCaller{contract: contract}, nil
+}
+
+// NewTestTransactor creates a new write-only instance of Test, bound to a specific deployed contract.
+func NewTestTransactor(address common.Address, transactor bind.ContractTransactor) (*TestTransactor, error) {
+	contract, err := bindTest(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &TestTransactor{contract: contract}, nil
+}
+
+// NewTestFilterer creates a new log filterer instance of Test, bound to a specific deployed contract.
+func NewTestFilterer(address common.Address, filterer bind.ContractFilterer) (*TestFilterer, error) {
+	contract, err := bindTest(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &TestFilterer{contract: contract}, nil
+}
+
+// bindTest binds a generic wrapper to an already deployed contract.
+func bindTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := TestMetaData.GetAbi()
+	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 (_Test *TestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Test.Contract.TestCaller.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 (_Test *TestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Test.Contract.TestTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Test *TestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Test.Contract.TestTransactor.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 (_Test *TestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Test.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 (_Test *TestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Test.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Test *TestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Test.Contract.contract.Transact(opts, method, params...)
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_Test *TestCaller) ISTEST(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _Test.contract.Call(opts, &out, "IS_TEST")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_Test *TestSession) ISTEST() (bool, error) {
+	return _Test.Contract.ISTEST(&_Test.CallOpts)
+}
+
+// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4.
+//
+// Solidity: function IS_TEST() view returns(bool)
+func (_Test *TestCallerSession) ISTEST() (bool, error) {
+	return _Test.Contract.ISTEST(&_Test.CallOpts)
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_Test *TestCaller) ExcludeArtifacts(opts *bind.CallOpts) ([]string, error) {
+	var out []interface{}
+	err := _Test.contract.Call(opts, &out, "excludeArtifacts")
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_Test *TestSession) ExcludeArtifacts() ([]string, error) {
+	return _Test.Contract.ExcludeArtifacts(&_Test.CallOpts)
+}
+
+// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9.
+//
+// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_)
+func (_Test *TestCallerSession) ExcludeArtifacts() ([]string, error) {
+	return _Test.Contract.ExcludeArtifacts(&_Test.CallOpts)
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_Test *TestCaller) ExcludeContracts(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _Test.contract.Call(opts, &out, "excludeContracts")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_Test *TestSession) ExcludeContracts() ([]common.Address, error) {
+	return _Test.Contract.ExcludeContracts(&_Test.CallOpts)
+}
+
+// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71.
+//
+// Solidity: function excludeContracts() view returns(address[] excludedContracts_)
+func (_Test *TestCallerSession) ExcludeContracts() ([]common.Address, error) {
+	return _Test.Contract.ExcludeContracts(&_Test.CallOpts)
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_Test *TestCaller) ExcludeSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) {
+	var out []interface{}
+	err := _Test.contract.Call(opts, &out, "excludeSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector)
+
+	return out0, err
+
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_Test *TestSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _Test.Contract.ExcludeSelectors(&_Test.CallOpts)
+}
+
+// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc.
+//
+// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_)
+func (_Test *TestCallerSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _Test.Contract.ExcludeSelectors(&_Test.CallOpts)
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_Test *TestCaller) ExcludeSenders(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _Test.contract.Call(opts, &out, "excludeSenders")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_Test *TestSession) ExcludeSenders() ([]common.Address, error) {
+	return _Test.Contract.ExcludeSenders(&_Test.CallOpts)
+}
+
+// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c.
+//
+// Solidity: function excludeSenders() view returns(address[] excludedSenders_)
+func (_Test *TestCallerSession) ExcludeSenders() ([]common.Address, error) {
+	return _Test.Contract.ExcludeSenders(&_Test.CallOpts)
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_Test *TestCaller) Failed(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _Test.contract.Call(opts, &out, "failed")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_Test *TestSession) Failed() (bool, error) {
+	return _Test.Contract.Failed(&_Test.CallOpts)
+}
+
+// Failed is a free data retrieval call binding the contract method 0xba414fa6.
+//
+// Solidity: function failed() view returns(bool)
+func (_Test *TestCallerSession) Failed() (bool, error) {
+	return _Test.Contract.Failed(&_Test.CallOpts)
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_Test *TestCaller) TargetArtifactSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzArtifactSelector, error) {
+	var out []interface{}
+	err := _Test.contract.Call(opts, &out, "targetArtifactSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzArtifactSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzArtifactSelector)).(*[]StdInvariantFuzzArtifactSelector)
+
+	return out0, err
+
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_Test *TestSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) {
+	return _Test.Contract.TargetArtifactSelectors(&_Test.CallOpts)
+}
+
+// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0.
+//
+// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_)
+func (_Test *TestCallerSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) {
+	return _Test.Contract.TargetArtifactSelectors(&_Test.CallOpts)
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_Test *TestCaller) TargetArtifacts(opts *bind.CallOpts) ([]string, error) {
+	var out []interface{}
+	err := _Test.contract.Call(opts, &out, "targetArtifacts")
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_Test *TestSession) TargetArtifacts() ([]string, error) {
+	return _Test.Contract.TargetArtifacts(&_Test.CallOpts)
+}
+
+// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81.
+//
+// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_)
+func (_Test *TestCallerSession) TargetArtifacts() ([]string, error) {
+	return _Test.Contract.TargetArtifacts(&_Test.CallOpts)
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_Test *TestCaller) TargetContracts(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _Test.contract.Call(opts, &out, "targetContracts")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_Test *TestSession) TargetContracts() ([]common.Address, error) {
+	return _Test.Contract.TargetContracts(&_Test.CallOpts)
+}
+
+// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4.
+//
+// Solidity: function targetContracts() view returns(address[] targetedContracts_)
+func (_Test *TestCallerSession) TargetContracts() ([]common.Address, error) {
+	return _Test.Contract.TargetContracts(&_Test.CallOpts)
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_Test *TestCaller) TargetInterfaces(opts *bind.CallOpts) ([]StdInvariantFuzzInterface, error) {
+	var out []interface{}
+	err := _Test.contract.Call(opts, &out, "targetInterfaces")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzInterface), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzInterface)).(*[]StdInvariantFuzzInterface)
+
+	return out0, err
+
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_Test *TestSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) {
+	return _Test.Contract.TargetInterfaces(&_Test.CallOpts)
+}
+
+// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880.
+//
+// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_)
+func (_Test *TestCallerSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) {
+	return _Test.Contract.TargetInterfaces(&_Test.CallOpts)
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_Test *TestCaller) TargetSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) {
+	var out []interface{}
+	err := _Test.contract.Call(opts, &out, "targetSelectors")
+
+	if err != nil {
+		return *new([]StdInvariantFuzzSelector), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector)
+
+	return out0, err
+
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_Test *TestSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _Test.Contract.TargetSelectors(&_Test.CallOpts)
+}
+
+// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6.
+//
+// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_)
+func (_Test *TestCallerSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) {
+	return _Test.Contract.TargetSelectors(&_Test.CallOpts)
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_Test *TestCaller) TargetSenders(opts *bind.CallOpts) ([]common.Address, error) {
+	var out []interface{}
+	err := _Test.contract.Call(opts, &out, "targetSenders")
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_Test *TestSession) TargetSenders() ([]common.Address, error) {
+	return _Test.Contract.TargetSenders(&_Test.CallOpts)
+}
+
+// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23.
+//
+// Solidity: function targetSenders() view returns(address[] targetedSenders_)
+func (_Test *TestCallerSession) TargetSenders() ([]common.Address, error) {
+	return _Test.Contract.TargetSenders(&_Test.CallOpts)
+}
+
+// TestLogIterator is returned from FilterLog and is used to iterate over the raw logs and unpacked data for Log events raised by the Test contract.
+type TestLogIterator struct {
+	Event *TestLog // 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 *TestLogIterator) 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(TestLog)
+			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(TestLog)
+		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 *TestLogIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLog represents a Log event raised by the Test contract.
+type TestLog struct {
+	Arg0 string
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLog is a free log retrieval operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_Test *TestFilterer) FilterLog(opts *bind.FilterOpts) (*TestLogIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogIterator{contract: _Test.contract, event: "log", logs: logs, sub: sub}, nil
+}
+
+// WatchLog is a free log subscription operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_Test *TestFilterer) WatchLog(opts *bind.WatchOpts, sink chan<- *TestLog) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log")
+	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(TestLog)
+				if err := _Test.contract.UnpackLog(event, "log", 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
+}
+
+// ParseLog is a log parse operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50.
+//
+// Solidity: event log(string arg0)
+func (_Test *TestFilterer) ParseLog(log types.Log) (*TestLog, error) {
+	event := new(TestLog)
+	if err := _Test.contract.UnpackLog(event, "log", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogAddressIterator is returned from FilterLogAddress and is used to iterate over the raw logs and unpacked data for LogAddress events raised by the Test contract.
+type TestLogAddressIterator struct {
+	Event *TestLogAddress // 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 *TestLogAddressIterator) 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(TestLogAddress)
+			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(TestLogAddress)
+		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 *TestLogAddressIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogAddressIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogAddress represents a LogAddress event raised by the Test contract.
+type TestLogAddress struct {
+	Arg0 common.Address
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogAddress is a free log retrieval operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_Test *TestFilterer) FilterLogAddress(opts *bind.FilterOpts) (*TestLogAddressIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_address")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogAddressIterator{contract: _Test.contract, event: "log_address", logs: logs, sub: sub}, nil
+}
+
+// WatchLogAddress is a free log subscription operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_Test *TestFilterer) WatchLogAddress(opts *bind.WatchOpts, sink chan<- *TestLogAddress) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_address")
+	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(TestLogAddress)
+				if err := _Test.contract.UnpackLog(event, "log_address", 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
+}
+
+// ParseLogAddress is a log parse operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3.
+//
+// Solidity: event log_address(address arg0)
+func (_Test *TestFilterer) ParseLogAddress(log types.Log) (*TestLogAddress, error) {
+	event := new(TestLogAddress)
+	if err := _Test.contract.UnpackLog(event, "log_address", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogArrayIterator is returned from FilterLogArray and is used to iterate over the raw logs and unpacked data for LogArray events raised by the Test contract.
+type TestLogArrayIterator struct {
+	Event *TestLogArray // 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 *TestLogArrayIterator) 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(TestLogArray)
+			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(TestLogArray)
+		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 *TestLogArrayIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogArrayIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogArray represents a LogArray event raised by the Test contract.
+type TestLogArray struct {
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray is a free log retrieval operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_Test *TestFilterer) FilterLogArray(opts *bind.FilterOpts) (*TestLogArrayIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_array")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogArrayIterator{contract: _Test.contract, event: "log_array", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray is a free log subscription operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_Test *TestFilterer) WatchLogArray(opts *bind.WatchOpts, sink chan<- *TestLogArray) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_array")
+	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(TestLogArray)
+				if err := _Test.contract.UnpackLog(event, "log_array", 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
+}
+
+// ParseLogArray is a log parse operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1.
+//
+// Solidity: event log_array(uint256[] val)
+func (_Test *TestFilterer) ParseLogArray(log types.Log) (*TestLogArray, error) {
+	event := new(TestLogArray)
+	if err := _Test.contract.UnpackLog(event, "log_array", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogArray0Iterator is returned from FilterLogArray0 and is used to iterate over the raw logs and unpacked data for LogArray0 events raised by the Test contract.
+type TestLogArray0Iterator struct {
+	Event *TestLogArray0 // 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 *TestLogArray0Iterator) 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(TestLogArray0)
+			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(TestLogArray0)
+		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 *TestLogArray0Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogArray0Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogArray0 represents a LogArray0 event raised by the Test contract.
+type TestLogArray0 struct {
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray0 is a free log retrieval operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_Test *TestFilterer) FilterLogArray0(opts *bind.FilterOpts) (*TestLogArray0Iterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_array0")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogArray0Iterator{contract: _Test.contract, event: "log_array0", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray0 is a free log subscription operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_Test *TestFilterer) WatchLogArray0(opts *bind.WatchOpts, sink chan<- *TestLogArray0) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_array0")
+	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(TestLogArray0)
+				if err := _Test.contract.UnpackLog(event, "log_array0", 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
+}
+
+// ParseLogArray0 is a log parse operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5.
+//
+// Solidity: event log_array(int256[] val)
+func (_Test *TestFilterer) ParseLogArray0(log types.Log) (*TestLogArray0, error) {
+	event := new(TestLogArray0)
+	if err := _Test.contract.UnpackLog(event, "log_array0", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogArray1Iterator is returned from FilterLogArray1 and is used to iterate over the raw logs and unpacked data for LogArray1 events raised by the Test contract.
+type TestLogArray1Iterator struct {
+	Event *TestLogArray1 // 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 *TestLogArray1Iterator) 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(TestLogArray1)
+			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(TestLogArray1)
+		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 *TestLogArray1Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogArray1Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogArray1 represents a LogArray1 event raised by the Test contract.
+type TestLogArray1 struct {
+	Val []common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogArray1 is a free log retrieval operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_Test *TestFilterer) FilterLogArray1(opts *bind.FilterOpts) (*TestLogArray1Iterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_array1")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogArray1Iterator{contract: _Test.contract, event: "log_array1", logs: logs, sub: sub}, nil
+}
+
+// WatchLogArray1 is a free log subscription operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_Test *TestFilterer) WatchLogArray1(opts *bind.WatchOpts, sink chan<- *TestLogArray1) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_array1")
+	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(TestLogArray1)
+				if err := _Test.contract.UnpackLog(event, "log_array1", 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
+}
+
+// ParseLogArray1 is a log parse operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2.
+//
+// Solidity: event log_array(address[] val)
+func (_Test *TestFilterer) ParseLogArray1(log types.Log) (*TestLogArray1, error) {
+	event := new(TestLogArray1)
+	if err := _Test.contract.UnpackLog(event, "log_array1", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogBytesIterator is returned from FilterLogBytes and is used to iterate over the raw logs and unpacked data for LogBytes events raised by the Test contract.
+type TestLogBytesIterator struct {
+	Event *TestLogBytes // 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 *TestLogBytesIterator) 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(TestLogBytes)
+			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(TestLogBytes)
+		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 *TestLogBytesIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogBytesIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogBytes represents a LogBytes event raised by the Test contract.
+type TestLogBytes struct {
+	Arg0 []byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogBytes is a free log retrieval operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_Test *TestFilterer) FilterLogBytes(opts *bind.FilterOpts) (*TestLogBytesIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_bytes")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogBytesIterator{contract: _Test.contract, event: "log_bytes", logs: logs, sub: sub}, nil
+}
+
+// WatchLogBytes is a free log subscription operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_Test *TestFilterer) WatchLogBytes(opts *bind.WatchOpts, sink chan<- *TestLogBytes) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_bytes")
+	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(TestLogBytes)
+				if err := _Test.contract.UnpackLog(event, "log_bytes", 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
+}
+
+// ParseLogBytes is a log parse operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20.
+//
+// Solidity: event log_bytes(bytes arg0)
+func (_Test *TestFilterer) ParseLogBytes(log types.Log) (*TestLogBytes, error) {
+	event := new(TestLogBytes)
+	if err := _Test.contract.UnpackLog(event, "log_bytes", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogBytes32Iterator is returned from FilterLogBytes32 and is used to iterate over the raw logs and unpacked data for LogBytes32 events raised by the Test contract.
+type TestLogBytes32Iterator struct {
+	Event *TestLogBytes32 // 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 *TestLogBytes32Iterator) 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(TestLogBytes32)
+			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(TestLogBytes32)
+		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 *TestLogBytes32Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogBytes32Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogBytes32 represents a LogBytes32 event raised by the Test contract.
+type TestLogBytes32 struct {
+	Arg0 [32]byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogBytes32 is a free log retrieval operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_Test *TestFilterer) FilterLogBytes32(opts *bind.FilterOpts) (*TestLogBytes32Iterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_bytes32")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogBytes32Iterator{contract: _Test.contract, event: "log_bytes32", logs: logs, sub: sub}, nil
+}
+
+// WatchLogBytes32 is a free log subscription operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_Test *TestFilterer) WatchLogBytes32(opts *bind.WatchOpts, sink chan<- *TestLogBytes32) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_bytes32")
+	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(TestLogBytes32)
+				if err := _Test.contract.UnpackLog(event, "log_bytes32", 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
+}
+
+// ParseLogBytes32 is a log parse operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3.
+//
+// Solidity: event log_bytes32(bytes32 arg0)
+func (_Test *TestFilterer) ParseLogBytes32(log types.Log) (*TestLogBytes32, error) {
+	event := new(TestLogBytes32)
+	if err := _Test.contract.UnpackLog(event, "log_bytes32", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogIntIterator is returned from FilterLogInt and is used to iterate over the raw logs and unpacked data for LogInt events raised by the Test contract.
+type TestLogIntIterator struct {
+	Event *TestLogInt // 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 *TestLogIntIterator) 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(TestLogInt)
+			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(TestLogInt)
+		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 *TestLogIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogInt represents a LogInt event raised by the Test contract.
+type TestLogInt struct {
+	Arg0 *big.Int
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogInt is a free log retrieval operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_Test *TestFilterer) FilterLogInt(opts *bind.FilterOpts) (*TestLogIntIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_int")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogIntIterator{contract: _Test.contract, event: "log_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogInt is a free log subscription operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_Test *TestFilterer) WatchLogInt(opts *bind.WatchOpts, sink chan<- *TestLogInt) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_int")
+	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(TestLogInt)
+				if err := _Test.contract.UnpackLog(event, "log_int", 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
+}
+
+// ParseLogInt is a log parse operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8.
+//
+// Solidity: event log_int(int256 arg0)
+func (_Test *TestFilterer) ParseLogInt(log types.Log) (*TestLogInt, error) {
+	event := new(TestLogInt)
+	if err := _Test.contract.UnpackLog(event, "log_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogNamedAddressIterator is returned from FilterLogNamedAddress and is used to iterate over the raw logs and unpacked data for LogNamedAddress events raised by the Test contract.
+type TestLogNamedAddressIterator struct {
+	Event *TestLogNamedAddress // 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 *TestLogNamedAddressIterator) 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(TestLogNamedAddress)
+			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(TestLogNamedAddress)
+		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 *TestLogNamedAddressIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogNamedAddressIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogNamedAddress represents a LogNamedAddress event raised by the Test contract.
+type TestLogNamedAddress struct {
+	Key string
+	Val common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedAddress is a free log retrieval operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_Test *TestFilterer) FilterLogNamedAddress(opts *bind.FilterOpts) (*TestLogNamedAddressIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_address")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogNamedAddressIterator{contract: _Test.contract, event: "log_named_address", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedAddress is a free log subscription operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_Test *TestFilterer) WatchLogNamedAddress(opts *bind.WatchOpts, sink chan<- *TestLogNamedAddress) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_address")
+	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(TestLogNamedAddress)
+				if err := _Test.contract.UnpackLog(event, "log_named_address", 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
+}
+
+// ParseLogNamedAddress is a log parse operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f.
+//
+// Solidity: event log_named_address(string key, address val)
+func (_Test *TestFilterer) ParseLogNamedAddress(log types.Log) (*TestLogNamedAddress, error) {
+	event := new(TestLogNamedAddress)
+	if err := _Test.contract.UnpackLog(event, "log_named_address", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogNamedArrayIterator is returned from FilterLogNamedArray and is used to iterate over the raw logs and unpacked data for LogNamedArray events raised by the Test contract.
+type TestLogNamedArrayIterator struct {
+	Event *TestLogNamedArray // 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 *TestLogNamedArrayIterator) 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(TestLogNamedArray)
+			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(TestLogNamedArray)
+		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 *TestLogNamedArrayIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogNamedArrayIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogNamedArray represents a LogNamedArray event raised by the Test contract.
+type TestLogNamedArray struct {
+	Key string
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray is a free log retrieval operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_Test *TestFilterer) FilterLogNamedArray(opts *bind.FilterOpts) (*TestLogNamedArrayIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_array")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogNamedArrayIterator{contract: _Test.contract, event: "log_named_array", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray is a free log subscription operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_Test *TestFilterer) WatchLogNamedArray(opts *bind.WatchOpts, sink chan<- *TestLogNamedArray) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_array")
+	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(TestLogNamedArray)
+				if err := _Test.contract.UnpackLog(event, "log_named_array", 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
+}
+
+// ParseLogNamedArray is a log parse operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb.
+//
+// Solidity: event log_named_array(string key, uint256[] val)
+func (_Test *TestFilterer) ParseLogNamedArray(log types.Log) (*TestLogNamedArray, error) {
+	event := new(TestLogNamedArray)
+	if err := _Test.contract.UnpackLog(event, "log_named_array", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogNamedArray0Iterator is returned from FilterLogNamedArray0 and is used to iterate over the raw logs and unpacked data for LogNamedArray0 events raised by the Test contract.
+type TestLogNamedArray0Iterator struct {
+	Event *TestLogNamedArray0 // 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 *TestLogNamedArray0Iterator) 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(TestLogNamedArray0)
+			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(TestLogNamedArray0)
+		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 *TestLogNamedArray0Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogNamedArray0Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogNamedArray0 represents a LogNamedArray0 event raised by the Test contract.
+type TestLogNamedArray0 struct {
+	Key string
+	Val []*big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray0 is a free log retrieval operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_Test *TestFilterer) FilterLogNamedArray0(opts *bind.FilterOpts) (*TestLogNamedArray0Iterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_array0")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogNamedArray0Iterator{contract: _Test.contract, event: "log_named_array0", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray0 is a free log subscription operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_Test *TestFilterer) WatchLogNamedArray0(opts *bind.WatchOpts, sink chan<- *TestLogNamedArray0) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_array0")
+	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(TestLogNamedArray0)
+				if err := _Test.contract.UnpackLog(event, "log_named_array0", 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
+}
+
+// ParseLogNamedArray0 is a log parse operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57.
+//
+// Solidity: event log_named_array(string key, int256[] val)
+func (_Test *TestFilterer) ParseLogNamedArray0(log types.Log) (*TestLogNamedArray0, error) {
+	event := new(TestLogNamedArray0)
+	if err := _Test.contract.UnpackLog(event, "log_named_array0", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogNamedArray1Iterator is returned from FilterLogNamedArray1 and is used to iterate over the raw logs and unpacked data for LogNamedArray1 events raised by the Test contract.
+type TestLogNamedArray1Iterator struct {
+	Event *TestLogNamedArray1 // 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 *TestLogNamedArray1Iterator) 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(TestLogNamedArray1)
+			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(TestLogNamedArray1)
+		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 *TestLogNamedArray1Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogNamedArray1Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogNamedArray1 represents a LogNamedArray1 event raised by the Test contract.
+type TestLogNamedArray1 struct {
+	Key string
+	Val []common.Address
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedArray1 is a free log retrieval operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_Test *TestFilterer) FilterLogNamedArray1(opts *bind.FilterOpts) (*TestLogNamedArray1Iterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_array1")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogNamedArray1Iterator{contract: _Test.contract, event: "log_named_array1", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedArray1 is a free log subscription operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_Test *TestFilterer) WatchLogNamedArray1(opts *bind.WatchOpts, sink chan<- *TestLogNamedArray1) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_array1")
+	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(TestLogNamedArray1)
+				if err := _Test.contract.UnpackLog(event, "log_named_array1", 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
+}
+
+// ParseLogNamedArray1 is a log parse operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd.
+//
+// Solidity: event log_named_array(string key, address[] val)
+func (_Test *TestFilterer) ParseLogNamedArray1(log types.Log) (*TestLogNamedArray1, error) {
+	event := new(TestLogNamedArray1)
+	if err := _Test.contract.UnpackLog(event, "log_named_array1", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogNamedBytesIterator is returned from FilterLogNamedBytes and is used to iterate over the raw logs and unpacked data for LogNamedBytes events raised by the Test contract.
+type TestLogNamedBytesIterator struct {
+	Event *TestLogNamedBytes // 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 *TestLogNamedBytesIterator) 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(TestLogNamedBytes)
+			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(TestLogNamedBytes)
+		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 *TestLogNamedBytesIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogNamedBytesIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogNamedBytes represents a LogNamedBytes event raised by the Test contract.
+type TestLogNamedBytes struct {
+	Key string
+	Val []byte
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedBytes is a free log retrieval operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_Test *TestFilterer) FilterLogNamedBytes(opts *bind.FilterOpts) (*TestLogNamedBytesIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_bytes")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogNamedBytesIterator{contract: _Test.contract, event: "log_named_bytes", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedBytes is a free log subscription operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_Test *TestFilterer) WatchLogNamedBytes(opts *bind.WatchOpts, sink chan<- *TestLogNamedBytes) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_bytes")
+	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(TestLogNamedBytes)
+				if err := _Test.contract.UnpackLog(event, "log_named_bytes", 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
+}
+
+// ParseLogNamedBytes is a log parse operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18.
+//
+// Solidity: event log_named_bytes(string key, bytes val)
+func (_Test *TestFilterer) ParseLogNamedBytes(log types.Log) (*TestLogNamedBytes, error) {
+	event := new(TestLogNamedBytes)
+	if err := _Test.contract.UnpackLog(event, "log_named_bytes", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogNamedBytes32Iterator is returned from FilterLogNamedBytes32 and is used to iterate over the raw logs and unpacked data for LogNamedBytes32 events raised by the Test contract.
+type TestLogNamedBytes32Iterator struct {
+	Event *TestLogNamedBytes32 // 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 *TestLogNamedBytes32Iterator) 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(TestLogNamedBytes32)
+			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(TestLogNamedBytes32)
+		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 *TestLogNamedBytes32Iterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogNamedBytes32Iterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogNamedBytes32 represents a LogNamedBytes32 event raised by the Test contract.
+type TestLogNamedBytes32 struct {
+	Key string
+	Val [32]byte
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedBytes32 is a free log retrieval operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_Test *TestFilterer) FilterLogNamedBytes32(opts *bind.FilterOpts) (*TestLogNamedBytes32Iterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_bytes32")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogNamedBytes32Iterator{contract: _Test.contract, event: "log_named_bytes32", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedBytes32 is a free log subscription operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_Test *TestFilterer) WatchLogNamedBytes32(opts *bind.WatchOpts, sink chan<- *TestLogNamedBytes32) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_bytes32")
+	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(TestLogNamedBytes32)
+				if err := _Test.contract.UnpackLog(event, "log_named_bytes32", 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
+}
+
+// ParseLogNamedBytes32 is a log parse operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99.
+//
+// Solidity: event log_named_bytes32(string key, bytes32 val)
+func (_Test *TestFilterer) ParseLogNamedBytes32(log types.Log) (*TestLogNamedBytes32, error) {
+	event := new(TestLogNamedBytes32)
+	if err := _Test.contract.UnpackLog(event, "log_named_bytes32", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogNamedDecimalIntIterator is returned from FilterLogNamedDecimalInt and is used to iterate over the raw logs and unpacked data for LogNamedDecimalInt events raised by the Test contract.
+type TestLogNamedDecimalIntIterator struct {
+	Event *TestLogNamedDecimalInt // 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 *TestLogNamedDecimalIntIterator) 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(TestLogNamedDecimalInt)
+			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(TestLogNamedDecimalInt)
+		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 *TestLogNamedDecimalIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogNamedDecimalIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogNamedDecimalInt represents a LogNamedDecimalInt event raised by the Test contract.
+type TestLogNamedDecimalInt struct {
+	Key      string
+	Val      *big.Int
+	Decimals *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedDecimalInt is a free log retrieval operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_Test *TestFilterer) FilterLogNamedDecimalInt(opts *bind.FilterOpts) (*TestLogNamedDecimalIntIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_decimal_int")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogNamedDecimalIntIterator{contract: _Test.contract, event: "log_named_decimal_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedDecimalInt is a free log subscription operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_Test *TestFilterer) WatchLogNamedDecimalInt(opts *bind.WatchOpts, sink chan<- *TestLogNamedDecimalInt) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_decimal_int")
+	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(TestLogNamedDecimalInt)
+				if err := _Test.contract.UnpackLog(event, "log_named_decimal_int", 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
+}
+
+// ParseLogNamedDecimalInt is a log parse operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95.
+//
+// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals)
+func (_Test *TestFilterer) ParseLogNamedDecimalInt(log types.Log) (*TestLogNamedDecimalInt, error) {
+	event := new(TestLogNamedDecimalInt)
+	if err := _Test.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogNamedDecimalUintIterator is returned from FilterLogNamedDecimalUint and is used to iterate over the raw logs and unpacked data for LogNamedDecimalUint events raised by the Test contract.
+type TestLogNamedDecimalUintIterator struct {
+	Event *TestLogNamedDecimalUint // 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 *TestLogNamedDecimalUintIterator) 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(TestLogNamedDecimalUint)
+			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(TestLogNamedDecimalUint)
+		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 *TestLogNamedDecimalUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogNamedDecimalUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogNamedDecimalUint represents a LogNamedDecimalUint event raised by the Test contract.
+type TestLogNamedDecimalUint struct {
+	Key      string
+	Val      *big.Int
+	Decimals *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedDecimalUint is a free log retrieval operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_Test *TestFilterer) FilterLogNamedDecimalUint(opts *bind.FilterOpts) (*TestLogNamedDecimalUintIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_decimal_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogNamedDecimalUintIterator{contract: _Test.contract, event: "log_named_decimal_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedDecimalUint is a free log subscription operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_Test *TestFilterer) WatchLogNamedDecimalUint(opts *bind.WatchOpts, sink chan<- *TestLogNamedDecimalUint) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_decimal_uint")
+	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(TestLogNamedDecimalUint)
+				if err := _Test.contract.UnpackLog(event, "log_named_decimal_uint", 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
+}
+
+// ParseLogNamedDecimalUint is a log parse operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b.
+//
+// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals)
+func (_Test *TestFilterer) ParseLogNamedDecimalUint(log types.Log) (*TestLogNamedDecimalUint, error) {
+	event := new(TestLogNamedDecimalUint)
+	if err := _Test.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogNamedIntIterator is returned from FilterLogNamedInt and is used to iterate over the raw logs and unpacked data for LogNamedInt events raised by the Test contract.
+type TestLogNamedIntIterator struct {
+	Event *TestLogNamedInt // 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 *TestLogNamedIntIterator) 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(TestLogNamedInt)
+			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(TestLogNamedInt)
+		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 *TestLogNamedIntIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogNamedIntIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogNamedInt represents a LogNamedInt event raised by the Test contract.
+type TestLogNamedInt struct {
+	Key string
+	Val *big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedInt is a free log retrieval operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_Test *TestFilterer) FilterLogNamedInt(opts *bind.FilterOpts) (*TestLogNamedIntIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_int")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogNamedIntIterator{contract: _Test.contract, event: "log_named_int", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedInt is a free log subscription operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_Test *TestFilterer) WatchLogNamedInt(opts *bind.WatchOpts, sink chan<- *TestLogNamedInt) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_int")
+	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(TestLogNamedInt)
+				if err := _Test.contract.UnpackLog(event, "log_named_int", 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
+}
+
+// ParseLogNamedInt is a log parse operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168.
+//
+// Solidity: event log_named_int(string key, int256 val)
+func (_Test *TestFilterer) ParseLogNamedInt(log types.Log) (*TestLogNamedInt, error) {
+	event := new(TestLogNamedInt)
+	if err := _Test.contract.UnpackLog(event, "log_named_int", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogNamedStringIterator is returned from FilterLogNamedString and is used to iterate over the raw logs and unpacked data for LogNamedString events raised by the Test contract.
+type TestLogNamedStringIterator struct {
+	Event *TestLogNamedString // 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 *TestLogNamedStringIterator) 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(TestLogNamedString)
+			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(TestLogNamedString)
+		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 *TestLogNamedStringIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogNamedStringIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogNamedString represents a LogNamedString event raised by the Test contract.
+type TestLogNamedString struct {
+	Key string
+	Val string
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedString is a free log retrieval operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_Test *TestFilterer) FilterLogNamedString(opts *bind.FilterOpts) (*TestLogNamedStringIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_string")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogNamedStringIterator{contract: _Test.contract, event: "log_named_string", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedString is a free log subscription operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_Test *TestFilterer) WatchLogNamedString(opts *bind.WatchOpts, sink chan<- *TestLogNamedString) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_string")
+	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(TestLogNamedString)
+				if err := _Test.contract.UnpackLog(event, "log_named_string", 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
+}
+
+// ParseLogNamedString is a log parse operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583.
+//
+// Solidity: event log_named_string(string key, string val)
+func (_Test *TestFilterer) ParseLogNamedString(log types.Log) (*TestLogNamedString, error) {
+	event := new(TestLogNamedString)
+	if err := _Test.contract.UnpackLog(event, "log_named_string", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogNamedUintIterator is returned from FilterLogNamedUint and is used to iterate over the raw logs and unpacked data for LogNamedUint events raised by the Test contract.
+type TestLogNamedUintIterator struct {
+	Event *TestLogNamedUint // 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 *TestLogNamedUintIterator) 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(TestLogNamedUint)
+			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(TestLogNamedUint)
+		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 *TestLogNamedUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogNamedUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogNamedUint represents a LogNamedUint event raised by the Test contract.
+type TestLogNamedUint struct {
+	Key string
+	Val *big.Int
+	Raw types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogNamedUint is a free log retrieval operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_Test *TestFilterer) FilterLogNamedUint(opts *bind.FilterOpts) (*TestLogNamedUintIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogNamedUintIterator{contract: _Test.contract, event: "log_named_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogNamedUint is a free log subscription operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_Test *TestFilterer) WatchLogNamedUint(opts *bind.WatchOpts, sink chan<- *TestLogNamedUint) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_uint")
+	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(TestLogNamedUint)
+				if err := _Test.contract.UnpackLog(event, "log_named_uint", 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
+}
+
+// ParseLogNamedUint is a log parse operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8.
+//
+// Solidity: event log_named_uint(string key, uint256 val)
+func (_Test *TestFilterer) ParseLogNamedUint(log types.Log) (*TestLogNamedUint, error) {
+	event := new(TestLogNamedUint)
+	if err := _Test.contract.UnpackLog(event, "log_named_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogStringIterator is returned from FilterLogString and is used to iterate over the raw logs and unpacked data for LogString events raised by the Test contract.
+type TestLogStringIterator struct {
+	Event *TestLogString // 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 *TestLogStringIterator) 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(TestLogString)
+			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(TestLogString)
+		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 *TestLogStringIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogStringIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogString represents a LogString event raised by the Test contract.
+type TestLogString struct {
+	Arg0 string
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogString is a free log retrieval operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_Test *TestFilterer) FilterLogString(opts *bind.FilterOpts) (*TestLogStringIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_string")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogStringIterator{contract: _Test.contract, event: "log_string", logs: logs, sub: sub}, nil
+}
+
+// WatchLogString is a free log subscription operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_Test *TestFilterer) WatchLogString(opts *bind.WatchOpts, sink chan<- *TestLogString) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_string")
+	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(TestLogString)
+				if err := _Test.contract.UnpackLog(event, "log_string", 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
+}
+
+// ParseLogString is a log parse operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b.
+//
+// Solidity: event log_string(string arg0)
+func (_Test *TestFilterer) ParseLogString(log types.Log) (*TestLogString, error) {
+	event := new(TestLogString)
+	if err := _Test.contract.UnpackLog(event, "log_string", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogUintIterator is returned from FilterLogUint and is used to iterate over the raw logs and unpacked data for LogUint events raised by the Test contract.
+type TestLogUintIterator struct {
+	Event *TestLogUint // 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 *TestLogUintIterator) 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(TestLogUint)
+			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(TestLogUint)
+		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 *TestLogUintIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogUintIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogUint represents a LogUint event raised by the Test contract.
+type TestLogUint struct {
+	Arg0 *big.Int
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogUint is a free log retrieval operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_Test *TestFilterer) FilterLogUint(opts *bind.FilterOpts) (*TestLogUintIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "log_uint")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogUintIterator{contract: _Test.contract, event: "log_uint", logs: logs, sub: sub}, nil
+}
+
+// WatchLogUint is a free log subscription operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_Test *TestFilterer) WatchLogUint(opts *bind.WatchOpts, sink chan<- *TestLogUint) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "log_uint")
+	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(TestLogUint)
+				if err := _Test.contract.UnpackLog(event, "log_uint", 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
+}
+
+// ParseLogUint is a log parse operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755.
+//
+// Solidity: event log_uint(uint256 arg0)
+func (_Test *TestFilterer) ParseLogUint(log types.Log) (*TestLogUint, error) {
+	event := new(TestLogUint)
+	if err := _Test.contract.UnpackLog(event, "log_uint", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestLogsIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for Logs events raised by the Test contract.
+type TestLogsIterator struct {
+	Event *TestLogs // 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 *TestLogsIterator) 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(TestLogs)
+			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(TestLogs)
+		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 *TestLogsIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *TestLogsIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// TestLogs represents a Logs event raised by the Test contract.
+type TestLogs struct {
+	Arg0 []byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterLogs is a free log retrieval operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_Test *TestFilterer) FilterLogs(opts *bind.FilterOpts) (*TestLogsIterator, error) {
+
+	logs, sub, err := _Test.contract.FilterLogs(opts, "logs")
+	if err != nil {
+		return nil, err
+	}
+	return &TestLogsIterator{contract: _Test.contract, event: "logs", logs: logs, sub: sub}, nil
+}
+
+// WatchLogs is a free log subscription operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_Test *TestFilterer) WatchLogs(opts *bind.WatchOpts, sink chan<- *TestLogs) (event.Subscription, error) {
+
+	logs, sub, err := _Test.contract.WatchLogs(opts, "logs")
+	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(TestLogs)
+				if err := _Test.contract.UnpackLog(event, "logs", 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
+}
+
+// ParseLogs is a log parse operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4.
+//
+// Solidity: event logs(bytes arg0)
+func (_Test *TestFilterer) ParseLogs(log types.Log) (*TestLogs, error) {
+	event := new(TestLogs)
+	if err := _Test.contract.UnpackLog(event, "logs", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// TestBaseMetaData contains all meta data concerning the TestBase contract.
+var TestBaseMetaData = &bind.MetaData{
+	ABI: "[]",
+}
+
+// TestBaseABI is the input ABI used to generate the binding from.
+// Deprecated: Use TestBaseMetaData.ABI instead.
+var TestBaseABI = TestBaseMetaData.ABI
+
+// TestBase is an auto generated Go binding around an Ethereum contract.
+type TestBase struct {
+	TestBaseCaller     // Read-only binding to the contract
+	TestBaseTransactor // Write-only binding to the contract
+	TestBaseFilterer   // Log filterer for contract events
+}
+
+// TestBaseCaller is an auto generated read-only Go binding around an Ethereum contract.
+type TestBaseCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// TestBaseTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type TestBaseTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// TestBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type TestBaseFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// TestBaseSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type TestBaseSession struct {
+	Contract     *TestBase         // 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
+}
+
+// TestBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type TestBaseCallerSession struct {
+	Contract *TestBaseCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts   // Call options to use throughout this session
+}
+
+// TestBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type TestBaseTransactorSession struct {
+	Contract     *TestBaseTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
+}
+
+// TestBaseRaw is an auto generated low-level Go binding around an Ethereum contract.
+type TestBaseRaw struct {
+	Contract *TestBase // Generic contract binding to access the raw methods on
+}
+
+// TestBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type TestBaseCallerRaw struct {
+	Contract *TestBaseCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// TestBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type TestBaseTransactorRaw struct {
+	Contract *TestBaseTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewTestBase creates a new instance of TestBase, bound to a specific deployed contract.
+func NewTestBase(address common.Address, backend bind.ContractBackend) (*TestBase, error) {
+	contract, err := bindTestBase(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &TestBase{TestBaseCaller: TestBaseCaller{contract: contract}, TestBaseTransactor: TestBaseTransactor{contract: contract}, TestBaseFilterer: TestBaseFilterer{contract: contract}}, nil
+}
+
+// NewTestBaseCaller creates a new read-only instance of TestBase, bound to a specific deployed contract.
+func NewTestBaseCaller(address common.Address, caller bind.ContractCaller) (*TestBaseCaller, error) {
+	contract, err := bindTestBase(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &TestBaseCaller{contract: contract}, nil
+}
+
+// NewTestBaseTransactor creates a new write-only instance of TestBase, bound to a specific deployed contract.
+func NewTestBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*TestBaseTransactor, error) {
+	contract, err := bindTestBase(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &TestBaseTransactor{contract: contract}, nil
+}
+
+// NewTestBaseFilterer creates a new log filterer instance of TestBase, bound to a specific deployed contract.
+func NewTestBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*TestBaseFilterer, error) {
+	contract, err := bindTestBase(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &TestBaseFilterer{contract: contract}, nil
+}
+
+// bindTestBase binds a generic wrapper to an already deployed contract.
+func bindTestBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := TestBaseMetaData.GetAbi()
+	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 (_TestBase *TestBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _TestBase.Contract.TestBaseCaller.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 (_TestBase *TestBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _TestBase.Contract.TestBaseTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_TestBase *TestBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _TestBase.Contract.TestBaseTransactor.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 (_TestBase *TestBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _TestBase.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 (_TestBase *TestBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _TestBase.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_TestBase *TestBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _TestBase.Contract.contract.Transact(opts, method, params...)
+}
+
+// U384MetaData contains all meta data concerning the U384 contract.
+var U384MetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220e2d11ce0572b1effadb48ce8de4d4988ce2879577176597417cef37bd32cc8fa64736f6c63430008190033",
+}
+
+// U384ABI is the input ABI used to generate the binding from.
+// Deprecated: Use U384MetaData.ABI instead.
+var U384ABI = U384MetaData.ABI
+
+// U384Bin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use U384MetaData.Bin instead.
+var U384Bin = U384MetaData.Bin
+
+// DeployU384 deploys a new Ethereum contract, binding an instance of U384 to it.
+func DeployU384(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *U384, error) {
+	parsed, err := U384MetaData.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(U384Bin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &U384{U384Caller: U384Caller{contract: contract}, U384Transactor: U384Transactor{contract: contract}, U384Filterer: U384Filterer{contract: contract}}, nil
+}
+
+// U384 is an auto generated Go binding around an Ethereum contract.
+type U384 struct {
+	U384Caller     // Read-only binding to the contract
+	U384Transactor // Write-only binding to the contract
+	U384Filterer   // Log filterer for contract events
+}
+
+// U384Caller is an auto generated read-only Go binding around an Ethereum contract.
+type U384Caller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// U384Transactor is an auto generated write-only Go binding around an Ethereum contract.
+type U384Transactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// U384Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type U384Filterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// U384Session is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type U384Session struct {
+	Contract     *U384             // 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
+}
+
+// U384CallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type U384CallerSession struct {
+	Contract *U384Caller   // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts // Call options to use throughout this session
+}
+
+// U384TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type U384TransactorSession struct {
+	Contract     *U384Transactor   // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// U384Raw is an auto generated low-level Go binding around an Ethereum contract.
+type U384Raw struct {
+	Contract *U384 // Generic contract binding to access the raw methods on
+}
+
+// U384CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type U384CallerRaw struct {
+	Contract *U384Caller // Generic read-only contract binding to access the raw methods on
+}
+
+// U384TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type U384TransactorRaw struct {
+	Contract *U384Transactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewU384 creates a new instance of U384, bound to a specific deployed contract.
+func NewU384(address common.Address, backend bind.ContractBackend) (*U384, error) {
+	contract, err := bindU384(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &U384{U384Caller: U384Caller{contract: contract}, U384Transactor: U384Transactor{contract: contract}, U384Filterer: U384Filterer{contract: contract}}, nil
+}
+
+// NewU384Caller creates a new read-only instance of U384, bound to a specific deployed contract.
+func NewU384Caller(address common.Address, caller bind.ContractCaller) (*U384Caller, error) {
+	contract, err := bindU384(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &U384Caller{contract: contract}, nil
+}
+
+// NewU384Transactor creates a new write-only instance of U384, bound to a specific deployed contract.
+func NewU384Transactor(address common.Address, transactor bind.ContractTransactor) (*U384Transactor, error) {
+	contract, err := bindU384(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &U384Transactor{contract: contract}, nil
+}
+
+// NewU384Filterer creates a new log filterer instance of U384, bound to a specific deployed contract.
+func NewU384Filterer(address common.Address, filterer bind.ContractFilterer) (*U384Filterer, error) {
+	contract, err := bindU384(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &U384Filterer{contract: contract}, nil
+}
+
+// bindU384 binds a generic wrapper to an already deployed contract.
+func bindU384(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := U384MetaData.GetAbi()
+	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 (_U384 *U384Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _U384.Contract.U384Caller.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 (_U384 *U384Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _U384.Contract.U384Transactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_U384 *U384Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _U384.Contract.U384Transactor.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 (_U384 *U384CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _U384.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 (_U384 *U384TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _U384.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_U384 *U384TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _U384.Contract.contract.Transact(opts, method, params...)
+}
+
+// V3QuoteVerifierMetaData contains all meta data concerning the V3QuoteVerifier contract.
+var V3QuoteVerifierMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_ecdsaVerifier\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_router\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"P256_VERIFIER\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pccsRouter\",\"outputs\":[{\"internalType\":\"contractIPCCSRouter\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"quoteVersion\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint16\",\"name\":\"version\",\"type\":\"uint16\"},{\"internalType\":\"bytes2\",\"name\":\"attestationKeyType\",\"type\":\"bytes2\"},{\"internalType\":\"bytes4\",\"name\":\"teeType\",\"type\":\"bytes4\"},{\"internalType\":\"bytes2\",\"name\":\"qeSvn\",\"type\":\"bytes2\"},{\"internalType\":\"bytes2\",\"name\":\"pceSvn\",\"type\":\"bytes2\"},{\"internalType\":\"bytes16\",\"name\":\"qeVendorId\",\"type\":\"bytes16\"},{\"internalType\":\"bytes20\",\"name\":\"userData\",\"type\":\"bytes20\"}],\"internalType\":\"structHeader\",\"name\":\"header\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"rawQuote\",\"type\":\"bytes\"}],\"name\":\"verifyQuote\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"output\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"outputBytes\",\"type\":\"bytes\"}],\"name\":\"verifyZkOutput\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"output\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+	Bin: "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",
+}
+
+// V3QuoteVerifierABI is the input ABI used to generate the binding from.
+// Deprecated: Use V3QuoteVerifierMetaData.ABI instead.
+var V3QuoteVerifierABI = V3QuoteVerifierMetaData.ABI
+
+// V3QuoteVerifierBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use V3QuoteVerifierMetaData.Bin instead.
+var V3QuoteVerifierBin = V3QuoteVerifierMetaData.Bin
+
+// DeployV3QuoteVerifier deploys a new Ethereum contract, binding an instance of V3QuoteVerifier to it.
+func DeployV3QuoteVerifier(auth *bind.TransactOpts, backend bind.ContractBackend, _ecdsaVerifier common.Address, _router common.Address) (common.Address, *types.Transaction, *V3QuoteVerifier, error) {
+	parsed, err := V3QuoteVerifierMetaData.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(V3QuoteVerifierBin), backend, _ecdsaVerifier, _router)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &V3QuoteVerifier{V3QuoteVerifierCaller: V3QuoteVerifierCaller{contract: contract}, V3QuoteVerifierTransactor: V3QuoteVerifierTransactor{contract: contract}, V3QuoteVerifierFilterer: V3QuoteVerifierFilterer{contract: contract}}, nil
+}
+
+// V3QuoteVerifier is an auto generated Go binding around an Ethereum contract.
+type V3QuoteVerifier struct {
+	V3QuoteVerifierCaller     // Read-only binding to the contract
+	V3QuoteVerifierTransactor // Write-only binding to the contract
+	V3QuoteVerifierFilterer   // Log filterer for contract events
+}
+
+// V3QuoteVerifierCaller is an auto generated read-only Go binding around an Ethereum contract.
+type V3QuoteVerifierCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// V3QuoteVerifierTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type V3QuoteVerifierTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// V3QuoteVerifierFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type V3QuoteVerifierFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// V3QuoteVerifierSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type V3QuoteVerifierSession struct {
+	Contract     *V3QuoteVerifier  // 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
+}
+
+// V3QuoteVerifierCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type V3QuoteVerifierCallerSession struct {
+	Contract *V3QuoteVerifierCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts          // Call options to use throughout this session
+}
+
+// V3QuoteVerifierTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type V3QuoteVerifierTransactorSession struct {
+	Contract     *V3QuoteVerifierTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts          // Transaction auth options to use throughout this session
+}
+
+// V3QuoteVerifierRaw is an auto generated low-level Go binding around an Ethereum contract.
+type V3QuoteVerifierRaw struct {
+	Contract *V3QuoteVerifier // Generic contract binding to access the raw methods on
+}
+
+// V3QuoteVerifierCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type V3QuoteVerifierCallerRaw struct {
+	Contract *V3QuoteVerifierCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// V3QuoteVerifierTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type V3QuoteVerifierTransactorRaw struct {
+	Contract *V3QuoteVerifierTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewV3QuoteVerifier creates a new instance of V3QuoteVerifier, bound to a specific deployed contract.
+func NewV3QuoteVerifier(address common.Address, backend bind.ContractBackend) (*V3QuoteVerifier, error) {
+	contract, err := bindV3QuoteVerifier(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &V3QuoteVerifier{V3QuoteVerifierCaller: V3QuoteVerifierCaller{contract: contract}, V3QuoteVerifierTransactor: V3QuoteVerifierTransactor{contract: contract}, V3QuoteVerifierFilterer: V3QuoteVerifierFilterer{contract: contract}}, nil
+}
+
+// NewV3QuoteVerifierCaller creates a new read-only instance of V3QuoteVerifier, bound to a specific deployed contract.
+func NewV3QuoteVerifierCaller(address common.Address, caller bind.ContractCaller) (*V3QuoteVerifierCaller, error) {
+	contract, err := bindV3QuoteVerifier(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &V3QuoteVerifierCaller{contract: contract}, nil
+}
+
+// NewV3QuoteVerifierTransactor creates a new write-only instance of V3QuoteVerifier, bound to a specific deployed contract.
+func NewV3QuoteVerifierTransactor(address common.Address, transactor bind.ContractTransactor) (*V3QuoteVerifierTransactor, error) {
+	contract, err := bindV3QuoteVerifier(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &V3QuoteVerifierTransactor{contract: contract}, nil
+}
+
+// NewV3QuoteVerifierFilterer creates a new log filterer instance of V3QuoteVerifier, bound to a specific deployed contract.
+func NewV3QuoteVerifierFilterer(address common.Address, filterer bind.ContractFilterer) (*V3QuoteVerifierFilterer, error) {
+	contract, err := bindV3QuoteVerifier(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &V3QuoteVerifierFilterer{contract: contract}, nil
+}
+
+// bindV3QuoteVerifier binds a generic wrapper to an already deployed contract.
+func bindV3QuoteVerifier(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := V3QuoteVerifierMetaData.GetAbi()
+	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 (_V3QuoteVerifier *V3QuoteVerifierRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _V3QuoteVerifier.Contract.V3QuoteVerifierCaller.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 (_V3QuoteVerifier *V3QuoteVerifierRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _V3QuoteVerifier.Contract.V3QuoteVerifierTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_V3QuoteVerifier *V3QuoteVerifierRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _V3QuoteVerifier.Contract.V3QuoteVerifierTransactor.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 (_V3QuoteVerifier *V3QuoteVerifierCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _V3QuoteVerifier.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 (_V3QuoteVerifier *V3QuoteVerifierTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _V3QuoteVerifier.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_V3QuoteVerifier *V3QuoteVerifierTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _V3QuoteVerifier.Contract.contract.Transact(opts, method, params...)
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_V3QuoteVerifier *V3QuoteVerifierCaller) P256VERIFIER(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _V3QuoteVerifier.contract.Call(opts, &out, "P256_VERIFIER")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_V3QuoteVerifier *V3QuoteVerifierSession) P256VERIFIER() (common.Address, error) {
+	return _V3QuoteVerifier.Contract.P256VERIFIER(&_V3QuoteVerifier.CallOpts)
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_V3QuoteVerifier *V3QuoteVerifierCallerSession) P256VERIFIER() (common.Address, error) {
+	return _V3QuoteVerifier.Contract.P256VERIFIER(&_V3QuoteVerifier.CallOpts)
+}
+
+// PccsRouter is a free data retrieval call binding the contract method 0x9e0fb0bf.
+//
+// Solidity: function pccsRouter() view returns(address)
+func (_V3QuoteVerifier *V3QuoteVerifierCaller) PccsRouter(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _V3QuoteVerifier.contract.Call(opts, &out, "pccsRouter")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// PccsRouter is a free data retrieval call binding the contract method 0x9e0fb0bf.
+//
+// Solidity: function pccsRouter() view returns(address)
+func (_V3QuoteVerifier *V3QuoteVerifierSession) PccsRouter() (common.Address, error) {
+	return _V3QuoteVerifier.Contract.PccsRouter(&_V3QuoteVerifier.CallOpts)
+}
+
+// PccsRouter is a free data retrieval call binding the contract method 0x9e0fb0bf.
+//
+// Solidity: function pccsRouter() view returns(address)
+func (_V3QuoteVerifier *V3QuoteVerifierCallerSession) PccsRouter() (common.Address, error) {
+	return _V3QuoteVerifier.Contract.PccsRouter(&_V3QuoteVerifier.CallOpts)
+}
+
+// QuoteVersion is a free data retrieval call binding the contract method 0x02077837.
+//
+// Solidity: function quoteVersion() view returns(uint16)
+func (_V3QuoteVerifier *V3QuoteVerifierCaller) QuoteVersion(opts *bind.CallOpts) (uint16, error) {
+	var out []interface{}
+	err := _V3QuoteVerifier.contract.Call(opts, &out, "quoteVersion")
+
+	if err != nil {
+		return *new(uint16), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint16)).(*uint16)
+
+	return out0, err
+
+}
+
+// QuoteVersion is a free data retrieval call binding the contract method 0x02077837.
+//
+// Solidity: function quoteVersion() view returns(uint16)
+func (_V3QuoteVerifier *V3QuoteVerifierSession) QuoteVersion() (uint16, error) {
+	return _V3QuoteVerifier.Contract.QuoteVersion(&_V3QuoteVerifier.CallOpts)
+}
+
+// QuoteVersion is a free data retrieval call binding the contract method 0x02077837.
+//
+// Solidity: function quoteVersion() view returns(uint16)
+func (_V3QuoteVerifier *V3QuoteVerifierCallerSession) QuoteVersion() (uint16, error) {
+	return _V3QuoteVerifier.Contract.QuoteVersion(&_V3QuoteVerifier.CallOpts)
+}
+
+// VerifyQuote is a free data retrieval call binding the contract method 0xf1495114.
+//
+// Solidity: function verifyQuote((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) header, bytes rawQuote) view returns(bool success, bytes output)
+func (_V3QuoteVerifier *V3QuoteVerifierCaller) VerifyQuote(opts *bind.CallOpts, header Header, rawQuote []byte) (struct {
+	Success bool
+	Output  []byte
+}, error) {
+	var out []interface{}
+	err := _V3QuoteVerifier.contract.Call(opts, &out, "verifyQuote", header, rawQuote)
+
+	outstruct := new(struct {
+		Success bool
+		Output  []byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.Success = *abi.ConvertType(out[0], new(bool)).(*bool)
+	outstruct.Output = *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return *outstruct, err
+
+}
+
+// VerifyQuote is a free data retrieval call binding the contract method 0xf1495114.
+//
+// Solidity: function verifyQuote((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) header, bytes rawQuote) view returns(bool success, bytes output)
+func (_V3QuoteVerifier *V3QuoteVerifierSession) VerifyQuote(header Header, rawQuote []byte) (struct {
+	Success bool
+	Output  []byte
+}, error) {
+	return _V3QuoteVerifier.Contract.VerifyQuote(&_V3QuoteVerifier.CallOpts, header, rawQuote)
+}
+
+// VerifyQuote is a free data retrieval call binding the contract method 0xf1495114.
+//
+// Solidity: function verifyQuote((uint16,bytes2,bytes4,bytes2,bytes2,bytes16,bytes20) header, bytes rawQuote) view returns(bool success, bytes output)
+func (_V3QuoteVerifier *V3QuoteVerifierCallerSession) VerifyQuote(header Header, rawQuote []byte) (struct {
+	Success bool
+	Output  []byte
+}, error) {
+	return _V3QuoteVerifier.Contract.VerifyQuote(&_V3QuoteVerifier.CallOpts, header, rawQuote)
+}
+
+// VerifyZkOutput is a free data retrieval call binding the contract method 0x9ffa5fd9.
+//
+// Solidity: function verifyZkOutput(bytes outputBytes) view returns(bool success, bytes output)
+func (_V3QuoteVerifier *V3QuoteVerifierCaller) VerifyZkOutput(opts *bind.CallOpts, outputBytes []byte) (struct {
+	Success bool
+	Output  []byte
+}, error) {
+	var out []interface{}
+	err := _V3QuoteVerifier.contract.Call(opts, &out, "verifyZkOutput", outputBytes)
+
+	outstruct := new(struct {
+		Success bool
+		Output  []byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.Success = *abi.ConvertType(out[0], new(bool)).(*bool)
+	outstruct.Output = *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return *outstruct, err
+
+}
+
+// VerifyZkOutput is a free data retrieval call binding the contract method 0x9ffa5fd9.
+//
+// Solidity: function verifyZkOutput(bytes outputBytes) view returns(bool success, bytes output)
+func (_V3QuoteVerifier *V3QuoteVerifierSession) VerifyZkOutput(outputBytes []byte) (struct {
+	Success bool
+	Output  []byte
+}, error) {
+	return _V3QuoteVerifier.Contract.VerifyZkOutput(&_V3QuoteVerifier.CallOpts, outputBytes)
+}
+
+// VerifyZkOutput is a free data retrieval call binding the contract method 0x9ffa5fd9.
+//
+// Solidity: function verifyZkOutput(bytes outputBytes) view returns(bool success, bytes output)
+func (_V3QuoteVerifier *V3QuoteVerifierCallerSession) VerifyZkOutput(outputBytes []byte) (struct {
+	Success bool
+	Output  []byte
+}, error) {
+	return _V3QuoteVerifier.Contract.VerifyZkOutput(&_V3QuoteVerifier.CallOpts, outputBytes)
+}
+
+// VmMetaData contains all meta data concerning the Vm contract.
+var VmMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32[]\",\"name\":\"storageKeys\",\"type\":\"bytes32[]\"}],\"internalType\":\"structVmSafe.AccessListItem[]\",\"name\":\"access\",\"type\":\"tuple[]\"}],\"name\":\"accessList\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"accesses\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"readSlots\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"writeSlots\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"activeFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"addr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"keyAddr\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"allowCheatcodes\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertFalse\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"}],\"name\":\"assertFalse\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"}],\"name\":\"assertTrue\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertTrue\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"}],\"name\":\"assume\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"assumeNoRevert\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"reverter\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"partialMatch\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"internalType\":\"structVmSafe.PotentialRevert[]\",\"name\":\"potentialReverts\",\"type\":\"tuple[]\"}],\"name\":\"assumeNoRevert\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"reverter\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"partialMatch\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"internalType\":\"structVmSafe.PotentialRevert\",\"name\":\"potentialRevert\",\"type\":\"tuple\"}],\"name\":\"assumeNoRevert\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"internalType\":\"structVmSafe.SignedDelegation\",\"name\":\"signedDelegation\",\"type\":\"tuple\"}],\"name\":\"attachDelegation\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newBlobBaseFee\",\"type\":\"uint256\"}],\"name\":\"blobBaseFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"hashes\",\"type\":\"bytes32[]\"}],\"name\":\"blobhashes\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"char\",\"type\":\"string\"}],\"name\":\"breakpoint\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"char\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"breakpoint\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"broadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"broadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"broadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"broadcastRawTransaction\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newChainId\",\"type\":\"uint256\"}],\"name\":\"chainId\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"clearMockedCalls\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"source\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"cloneAccount\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"closeFile\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newCoinbase\",\"type\":\"address\"}],\"name\":\"coinbase\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"initCodeHash\",\"type\":\"bytes32\"}],\"name\":\"computeCreate2Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"initCodeHash\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"deployer\",\"type\":\"address\"}],\"name\":\"computeCreate2Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"deployer\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"computeCreateAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"subject\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"search\",\"type\":\"string\"}],\"name\":\"contains\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"cool\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"}],\"name\":\"coolSlot\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"from\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"to\",\"type\":\"string\"}],\"name\":\"copyFile\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"copied\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"copyStorage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"recursive\",\"type\":\"bool\"}],\"name\":\"createDir\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"}],\"name\":\"createFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"name\":\"createFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"}],\"name\":\"createFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"name\":\"createSelectFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"}],\"name\":\"createSelectFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"}],\"name\":\"createSelectFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"walletLabel\",\"type\":\"string\"}],\"name\":\"createWallet\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"createWallet\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"walletLabel\",\"type\":\"string\"}],\"name\":\"createWallet\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"newBalance\",\"type\":\"uint256\"}],\"name\":\"deal\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"snapshotId\",\"type\":\"uint256\"}],\"name\":\"deleteSnapshot\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"deleteSnapshots\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"snapshotId\",\"type\":\"uint256\"}],\"name\":\"deleteStateSnapshot\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"deleteStateSnapshots\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"artifactPath\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"constructorArgs\",\"type\":\"bytes\"}],\"name\":\"deployCode\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"deployedAddress\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"artifactPath\",\"type\":\"string\"}],\"name\":\"deployCode\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"deployedAddress\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"derivationPath\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"internalType\":\"string\",\"name\":\"language\",\"type\":\"string\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"internalType\":\"string\",\"name\":\"language\",\"type\":\"string\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"derivationPath\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newDifficulty\",\"type\":\"uint256\"}],\"name\":\"difficulty\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"pathToStateJson\",\"type\":\"string\"}],\"name\":\"dumpState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"ensNamehash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envAddress\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"value\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envBool\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"value\",\"type\":\"bool[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envBytes\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"value\",\"type\":\"bytes[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envBytes32\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"value\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envExists\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envInt\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"value\",\"type\":\"int256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"bytes32[]\",\"name\":\"defaultValue\",\"type\":\"bytes32[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"value\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"int256[]\",\"name\":\"defaultValue\",\"type\":\"int256[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"value\",\"type\":\"int256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"defaultValue\",\"type\":\"bool\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"defaultValue\",\"type\":\"address\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"defaultValue\",\"type\":\"uint256\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"bytes[]\",\"name\":\"defaultValue\",\"type\":\"bytes[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"value\",\"type\":\"bytes[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"defaultValue\",\"type\":\"uint256[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"value\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"string[]\",\"name\":\"defaultValue\",\"type\":\"string[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"value\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"defaultValue\",\"type\":\"bytes\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"defaultValue\",\"type\":\"bytes32\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"int256\",\"name\":\"defaultValue\",\"type\":\"int256\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"address[]\",\"name\":\"defaultValue\",\"type\":\"address[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"value\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"defaultValue\",\"type\":\"string\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"bool[]\",\"name\":\"defaultValue\",\"type\":\"bool[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"value\",\"type\":\"bool[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envString\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"value\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envUint\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"value\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"newRuntimeBytecode\",\"type\":\"bytes\"}],\"name\":\"etch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"fromBlock\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBlock\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32[]\",\"name\":\"topics\",\"type\":\"bytes32[]\"}],\"name\":\"eth_getLogs\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"},{\"internalType\":\"bytes32[]\",\"name\":\"topics\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"transactionHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"transactionIndex\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"logIndex\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"removed\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.EthGetLogs[]\",\"name\":\"logs\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"exists\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"gas\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"expectCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"gas\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"expectCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"expectCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"minGas\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"expectCallMinGas\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"minGas\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectCallMinGas\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"bytecode\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"deployer\",\"type\":\"address\"}],\"name\":\"expectCreate\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"bytecode\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"deployer\",\"type\":\"address\"}],\"name\":\"expectCreate2\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"expectEmit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"checkTopic1\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic2\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic3\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkData\",\"type\":\"bool\"}],\"name\":\"expectEmit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectEmit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"checkTopic1\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic2\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic3\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkData\",\"type\":\"bool\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectEmit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"checkTopic1\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic2\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic3\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkData\",\"type\":\"bool\"},{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"}],\"name\":\"expectEmit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"}],\"name\":\"expectEmit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectEmit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"checkTopic1\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic2\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic3\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkData\",\"type\":\"bool\"},{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectEmit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"expectEmitAnonymous\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"}],\"name\":\"expectEmitAnonymous\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"checkTopic0\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic1\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic2\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic3\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkData\",\"type\":\"bool\"},{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"}],\"name\":\"expectEmitAnonymous\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"checkTopic0\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic1\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic2\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic3\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkData\",\"type\":\"bool\"}],\"name\":\"expectEmitAnonymous\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"revertData\",\"type\":\"bytes4\"}],\"name\":\"expectPartialRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"revertData\",\"type\":\"bytes4\"},{\"internalType\":\"address\",\"name\":\"reverter\",\"type\":\"address\"}],\"name\":\"expectPartialRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"reverter\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"revertData\",\"type\":\"bytes4\"},{\"internalType\":\"address\",\"name\":\"reverter\",\"type\":\"address\"}],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"reverter\",\"type\":\"address\"}],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"revertData\",\"type\":\"bytes4\"},{\"internalType\":\"address\",\"name\":\"reverter\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"revertData\",\"type\":\"bytes4\"}],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"reverter\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"reverter\",\"type\":\"address\"}],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"revertData\",\"type\":\"bytes4\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"min\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"max\",\"type\":\"uint64\"}],\"name\":\"expectSafeMemory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"min\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"max\",\"type\":\"uint64\"}],\"name\":\"expectSafeMemoryCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newBasefee\",\"type\":\"uint256\"}],\"name\":\"fee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"commandInput\",\"type\":\"string[]\"}],\"name\":\"ffi\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"result\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"version\",\"type\":\"string\"}],\"name\":\"foundryVersionAtLeast\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"version\",\"type\":\"string\"}],\"name\":\"foundryVersionCmp\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"fsMetadata\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"readOnly\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"modified\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"accessed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"created\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.FsMetadata\",\"name\":\"metadata\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"code\",\"type\":\"bytes\"}],\"name\":\"getArtifactPathByCode\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"deployedCode\",\"type\":\"bytes\"}],\"name\":\"getArtifactPathByDeployedCode\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlobBaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"blobBaseFee\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlobhashes\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"hashes\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"height\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlockTimestamp\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"contractName\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"chainId\",\"type\":\"uint64\"},{\"internalType\":\"enumVmSafe.BroadcastTxType\",\"name\":\"txType\",\"type\":\"uint8\"}],\"name\":\"getBroadcast\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"},{\"internalType\":\"enumVmSafe.BroadcastTxType\",\"name\":\"txType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"contractAddress\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.BroadcastTxSummary\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"contractName\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"chainId\",\"type\":\"uint64\"}],\"name\":\"getBroadcasts\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"},{\"internalType\":\"enumVmSafe.BroadcastTxType\",\"name\":\"txType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"contractAddress\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.BroadcastTxSummary[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"contractName\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"chainId\",\"type\":\"uint64\"},{\"internalType\":\"enumVmSafe.BroadcastTxType\",\"name\":\"txType\",\"type\":\"uint8\"}],\"name\":\"getBroadcasts\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"},{\"internalType\":\"enumVmSafe.BroadcastTxType\",\"name\":\"txType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"contractAddress\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.BroadcastTxSummary[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"artifactPath\",\"type\":\"string\"}],\"name\":\"getCode\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"creationBytecode\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"artifactPath\",\"type\":\"string\"}],\"name\":\"getDeployedCode\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"runtimeBytecode\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"contractName\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"chainId\",\"type\":\"uint64\"}],\"name\":\"getDeployment\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"deployedAddress\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"contractName\",\"type\":\"string\"}],\"name\":\"getDeployment\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"deployedAddress\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"contractName\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"chainId\",\"type\":\"uint64\"}],\"name\":\"getDeployments\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"deployedAddresses\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getFoundryVersion\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"version\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getLabel\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"currentLabel\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"elementSlot\",\"type\":\"bytes32\"}],\"name\":\"getMappingKeyAndParentOf\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"found\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"parent\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"mappingSlot\",\"type\":\"bytes32\"}],\"name\":\"getMappingLength\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"mappingSlot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"idx\",\"type\":\"uint256\"}],\"name\":\"getMappingSlotAt\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getNonce\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"name\":\"getNonce\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRecordedLogs\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32[]\",\"name\":\"topics\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"}],\"internalType\":\"structVmSafe.Log[]\",\"name\":\"logs\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getStateDiff\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"diff\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getStateDiffJson\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"diff\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getWallets\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"wallets\",\"type\":\"address[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"indexOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumVmSafe.ForgeContext\",\"name\":\"context\",\"type\":\"uint8\"}],\"name\":\"isContext\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"isDir\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"isFile\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isPersistent\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"persistent\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"keyExists\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"keyExistsJson\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"keyExistsToml\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"newLabel\",\"type\":\"string\"}],\"name\":\"label\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastCallGas\",\"outputs\":[{\"components\":[{\"internalType\":\"uint64\",\"name\":\"gasLimit\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"gasTotalUsed\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"gasMemoryUsed\",\"type\":\"uint64\"},{\"internalType\":\"int64\",\"name\":\"gasRefunded\",\"type\":\"int64\"},{\"internalType\":\"uint64\",\"name\":\"gasRemaining\",\"type\":\"uint64\"}],\"internalType\":\"structVmSafe.Gas\",\"name\":\"gas\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"}],\"name\":\"load\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"data\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"pathToAllocsJson\",\"type\":\"string\"}],\"name\":\"loadAllocs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"accounts\",\"type\":\"address[]\"}],\"name\":\"makePersistent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account0\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account1\",\"type\":\"address\"}],\"name\":\"makePersistent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"makePersistent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account0\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account1\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account2\",\"type\":\"address\"}],\"name\":\"makePersistent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"bytes4\",\"name\":\"data\",\"type\":\"bytes4\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"name\":\"mockCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"name\":\"mockCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"name\":\"mockCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"bytes4\",\"name\":\"data\",\"type\":\"bytes4\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"name\":\"mockCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"bytes4\",\"name\":\"data\",\"type\":\"bytes4\"},{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"name\":\"mockCallRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"bytes4\",\"name\":\"data\",\"type\":\"bytes4\"},{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"name\":\"mockCallRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"name\":\"mockCallRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"name\":\"mockCallRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes[]\",\"name\":\"returnData\",\"type\":\"bytes[]\"}],\"name\":\"mockCalls\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes[]\",\"name\":\"returnData\",\"type\":\"bytes[]\"}],\"name\":\"mockCalls\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"mockFunction\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"noAccessList\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"parsedValue\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"parsedValue\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"parsedValue\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"parsedValue\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"parsedValue\",\"type\":\"int256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"name\":\"parseJson\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJson\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonAddressArray\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBoolArray\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"\",\"type\":\"bool[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytes32Array\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytesArray\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"\",\"type\":\"bytes[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonIntArray\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"\",\"type\":\"int256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonKeys\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"keys\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonStringArray\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"}],\"name\":\"parseJsonType\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"}],\"name\":\"parseJsonType\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"}],\"name\":\"parseJsonTypeArray\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonUintArray\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseToml\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"}],\"name\":\"parseToml\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlAddressArray\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBoolArray\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"\",\"type\":\"bool[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytes32Array\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytesArray\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"\",\"type\":\"bytes[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlIntArray\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"\",\"type\":\"int256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlKeys\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"keys\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlStringArray\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"}],\"name\":\"parseTomlType\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"}],\"name\":\"parseTomlType\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"}],\"name\":\"parseTomlTypeArray\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlUintArray\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"parsedValue\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseGasMetering\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseTracing\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"txOrigin\",\"type\":\"address\"}],\"name\":\"prank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"txOrigin\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"delegateCall\",\"type\":\"bool\"}],\"name\":\"prank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"delegateCall\",\"type\":\"bool\"}],\"name\":\"prank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"}],\"name\":\"prank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"newPrevrandao\",\"type\":\"bytes32\"}],\"name\":\"prevrandao\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newPrevrandao\",\"type\":\"uint256\"}],\"name\":\"prevrandao\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"projectRoot\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"prompt\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptSecret\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptSecretUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"publicKeyP256\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"len\",\"type\":\"uint256\"}],\"name\":\"randomBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomBytes4\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomBytes8\",\"outputs\":[{\"internalType\":\"bytes8\",\"name\":\"\",\"type\":\"bytes8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"bits\",\"type\":\"uint256\"}],\"name\":\"randomInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"bits\",\"type\":\"uint256\"}],\"name\":\"randomUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"min\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"max\",\"type\":\"uint256\"}],\"name\":\"randomUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"readCallers\",\"outputs\":[{\"internalType\":\"enumVmSafe.CallerMode\",\"name\":\"callerMode\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"txOrigin\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"maxDepth\",\"type\":\"uint64\"}],\"name\":\"readDir\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"errorMessage\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.DirEntry[]\",\"name\":\"entries\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"maxDepth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"followLinks\",\"type\":\"bool\"}],\"name\":\"readDir\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"errorMessage\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.DirEntry[]\",\"name\":\"entries\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readDir\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"errorMessage\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.DirEntry[]\",\"name\":\"entries\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readFile\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readFileBinary\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readLine\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"line\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"linkPath\",\"type\":\"string\"}],\"name\":\"readLink\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"targetPath\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"record\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"recordLogs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"rememberKey\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"keyAddr\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"derivationPath\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"count\",\"type\":\"uint32\"}],\"name\":\"rememberKeys\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"keyAddrs\",\"type\":\"address[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"derivationPath\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"language\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"count\",\"type\":\"uint32\"}],\"name\":\"rememberKeys\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"keyAddrs\",\"type\":\"address[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"recursive\",\"type\":\"bool\"}],\"name\":\"removeDir\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"removeFile\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"from\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"to\",\"type\":\"string\"}],\"name\":\"replace\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resetGasMetering\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"resetNonce\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resumeGasMetering\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resumeTracing\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"snapshotId\",\"type\":\"uint256\"}],\"name\":\"revertTo\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"snapshotId\",\"type\":\"uint256\"}],\"name\":\"revertToAndDelete\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"snapshotId\",\"type\":\"uint256\"}],\"name\":\"revertToState\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"snapshotId\",\"type\":\"uint256\"}],\"name\":\"revertToStateAndDelete\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"accounts\",\"type\":\"address[]\"}],\"name\":\"revokePersistent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"revokePersistent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newHeight\",\"type\":\"uint256\"}],\"name\":\"roll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"}],\"name\":\"rollFork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"name\":\"rollFork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"name\":\"rollFork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"}],\"name\":\"rollFork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"method\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"params\",\"type\":\"string\"}],\"name\":\"rpc\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"method\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"params\",\"type\":\"string\"}],\"name\":\"rpc\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"rpcAlias\",\"type\":\"string\"}],\"name\":\"rpcUrl\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rpcUrlStructs\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"url\",\"type\":\"string\"}],\"internalType\":\"structVmSafe.Rpc[]\",\"name\":\"urls\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rpcUrls\",\"outputs\":[{\"internalType\":\"string[2][]\",\"name\":\"urls\",\"type\":\"string[2][]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"name\":\"selectFork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"address[]\",\"name\":\"values\",\"type\":\"address[]\"}],\"name\":\"serializeAddress\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"name\":\"serializeAddress\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bool[]\",\"name\":\"values\",\"type\":\"bool[]\"}],\"name\":\"serializeBool\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"serializeBool\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes[]\",\"name\":\"values\",\"type\":\"bytes[]\"}],\"name\":\"serializeBytes\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"serializeBytes\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes32[]\",\"name\":\"values\",\"type\":\"bytes32[]\"}],\"name\":\"serializeBytes32\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"name\":\"serializeBytes32\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"name\":\"serializeInt\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"int256[]\",\"name\":\"values\",\"type\":\"int256[]\"}],\"name\":\"serializeInt\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"name\":\"serializeJson\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"serializeJsonType\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"serializeJsonType\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"string[]\",\"name\":\"values\",\"type\":\"string[]\"}],\"name\":\"serializeString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"name\":\"serializeString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"serializeUint\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"values\",\"type\":\"uint256[]\"}],\"name\":\"serializeUint\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"serializeUintToHex\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"setArbitraryStorage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"}],\"name\":\"setBlockhash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"name\":\"setEnv\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"newNonce\",\"type\":\"uint64\"}],\"name\":\"setNonce\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"newNonce\",\"type\":\"uint64\"}],\"name\":\"setNonceUnsafe\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"signAndAttachDelegation\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"internalType\":\"structVmSafe.SignedDelegation\",\"name\":\"signedDelegation\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"signCompact\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"vs\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"signCompact\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"vs\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"signCompact\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"vs\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"signCompact\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"vs\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"signDelegation\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"internalType\":\"structVmSafe.SignedDelegation\",\"name\":\"signedDelegation\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"signP256\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"skipTest\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"reason\",\"type\":\"string\"}],\"name\":\"skip\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"skipTest\",\"type\":\"bool\"}],\"name\":\"skip\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"duration\",\"type\":\"uint256\"}],\"name\":\"sleep\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"snapshot\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"snapshotId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"group\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"snapshotGasLastCall\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"gasUsed\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"snapshotGasLastCall\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"gasUsed\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"snapshotState\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"snapshotId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"snapshotValue\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"group\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"snapshotValue\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delimiter\",\"type\":\"string\"}],\"name\":\"split\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"outputs\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"startBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"startBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startDebugTraceRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startMappingRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"}],\"name\":\"startPrank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"delegateCall\",\"type\":\"bool\"}],\"name\":\"startPrank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"txOrigin\",\"type\":\"address\"}],\"name\":\"startPrank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"txOrigin\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"delegateCall\",\"type\":\"bool\"}],\"name\":\"startPrank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"startSnapshotGas\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"group\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"startSnapshotGas\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startStateDiffRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopAndReturnDebugTraceRecording\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256[]\",\"name\":\"stack\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"memoryInput\",\"type\":\"bytes\"},{\"internalType\":\"uint8\",\"name\":\"opcode\",\"type\":\"uint8\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isOutOfGas\",\"type\":\"bool\"},{\"internalType\":\"address\",\"name\":\"contractAddr\",\"type\":\"address\"}],\"internalType\":\"structVmSafe.DebugStep[]\",\"name\":\"step\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopAndReturnStateDiff\",\"outputs\":[{\"components\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.ChainInfo\",\"name\":\"chainInfo\",\"type\":\"tuple\"},{\"internalType\":\"enumVmSafe.AccountAccessKind\",\"name\":\"kind\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"accessor\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"initialized\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"oldBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"newBalance\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"deployedCode\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bool\",\"name\":\"reverted\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"},{\"internalType\":\"bool\",\"name\":\"isWrite\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"previousValue\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newValue\",\"type\":\"bytes32\"},{\"internalType\":\"bool\",\"name\":\"reverted\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.StorageAccess[]\",\"name\":\"storageAccesses\",\"type\":\"tuple[]\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"}],\"internalType\":\"structVmSafe.AccountAccess[]\",\"name\":\"accountAccesses\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopExpectSafeMemory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopMappingRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopPrank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"group\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"stopSnapshotGas\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"gasUsed\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"stopSnapshotGas\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"gasUsed\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopSnapshotGas\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"gasUsed\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"name\":\"store\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"toBase64\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"toBase64\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"toBase64URL\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"toBase64URL\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"name\":\"toLowercase\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"name\":\"toUppercase\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"}],\"name\":\"transact\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"}],\"name\":\"transact\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"name\":\"trim\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"commandInput\",\"type\":\"string[]\"}],\"name\":\"tryFfi\",\"outputs\":[{\"components\":[{\"internalType\":\"int32\",\"name\":\"exitCode\",\"type\":\"int32\"},{\"internalType\":\"bytes\",\"name\":\"stdout\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"stderr\",\"type\":\"bytes\"}],\"internalType\":\"structVmSafe.FfiResult\",\"name\":\"result\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newGasPrice\",\"type\":\"uint256\"}],\"name\":\"txGasPrice\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unixTime\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"milliseconds\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"}],\"name\":\"warmSlot\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newTimestamp\",\"type\":\"uint256\"}],\"name\":\"warp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"writeFile\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"writeFileBinary\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"}],\"name\":\"writeJson\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"writeJson\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"writeLine\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"}],\"name\":\"writeToml\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"writeToml\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
+}
+
+// VmABI is the input ABI used to generate the binding from.
+// Deprecated: Use VmMetaData.ABI instead.
+var VmABI = VmMetaData.ABI
+
+// Vm is an auto generated Go binding around an Ethereum contract.
+type Vm struct {
+	VmCaller     // Read-only binding to the contract
+	VmTransactor // Write-only binding to the contract
+	VmFilterer   // Log filterer for contract events
+}
+
+// VmCaller is an auto generated read-only Go binding around an Ethereum contract.
+type VmCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// VmTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type VmTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// VmFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type VmFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// VmSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type VmSession struct {
+	Contract     *Vm               // 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
+}
+
+// VmCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type VmCallerSession struct {
+	Contract *VmCaller     // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts // Call options to use throughout this session
+}
+
+// VmTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type VmTransactorSession struct {
+	Contract     *VmTransactor     // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// VmRaw is an auto generated low-level Go binding around an Ethereum contract.
+type VmRaw struct {
+	Contract *Vm // Generic contract binding to access the raw methods on
+}
+
+// VmCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type VmCallerRaw struct {
+	Contract *VmCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// VmTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type VmTransactorRaw struct {
+	Contract *VmTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewVm creates a new instance of Vm, bound to a specific deployed contract.
+func NewVm(address common.Address, backend bind.ContractBackend) (*Vm, error) {
+	contract, err := bindVm(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Vm{VmCaller: VmCaller{contract: contract}, VmTransactor: VmTransactor{contract: contract}, VmFilterer: VmFilterer{contract: contract}}, nil
+}
+
+// NewVmCaller creates a new read-only instance of Vm, bound to a specific deployed contract.
+func NewVmCaller(address common.Address, caller bind.ContractCaller) (*VmCaller, error) {
+	contract, err := bindVm(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &VmCaller{contract: contract}, nil
+}
+
+// NewVmTransactor creates a new write-only instance of Vm, bound to a specific deployed contract.
+func NewVmTransactor(address common.Address, transactor bind.ContractTransactor) (*VmTransactor, error) {
+	contract, err := bindVm(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &VmTransactor{contract: contract}, nil
+}
+
+// NewVmFilterer creates a new log filterer instance of Vm, bound to a specific deployed contract.
+func NewVmFilterer(address common.Address, filterer bind.ContractFilterer) (*VmFilterer, error) {
+	contract, err := bindVm(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &VmFilterer{contract: contract}, nil
+}
+
+// bindVm binds a generic wrapper to an already deployed contract.
+func bindVm(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := VmMetaData.GetAbi()
+	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 (_Vm *VmRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Vm.Contract.VmCaller.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 (_Vm *VmRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.Contract.VmTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Vm *VmRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Vm.Contract.VmTransactor.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 (_Vm *VmCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Vm.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 (_Vm *VmTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Vm *VmTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Vm.Contract.contract.Transact(opts, method, params...)
+}
+
+// ActiveFork is a free data retrieval call binding the contract method 0x2f103f22.
+//
+// Solidity: function activeFork() view returns(uint256 forkId)
+func (_Vm *VmCaller) ActiveFork(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "activeFork")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ActiveFork is a free data retrieval call binding the contract method 0x2f103f22.
+//
+// Solidity: function activeFork() view returns(uint256 forkId)
+func (_Vm *VmSession) ActiveFork() (*big.Int, error) {
+	return _Vm.Contract.ActiveFork(&_Vm.CallOpts)
+}
+
+// ActiveFork is a free data retrieval call binding the contract method 0x2f103f22.
+//
+// Solidity: function activeFork() view returns(uint256 forkId)
+func (_Vm *VmCallerSession) ActiveFork() (*big.Int, error) {
+	return _Vm.Contract.ActiveFork(&_Vm.CallOpts)
+}
+
+// Addr is a free data retrieval call binding the contract method 0xffa18649.
+//
+// Solidity: function addr(uint256 privateKey) pure returns(address keyAddr)
+func (_Vm *VmCaller) Addr(opts *bind.CallOpts, privateKey *big.Int) (common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "addr", privateKey)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// Addr is a free data retrieval call binding the contract method 0xffa18649.
+//
+// Solidity: function addr(uint256 privateKey) pure returns(address keyAddr)
+func (_Vm *VmSession) Addr(privateKey *big.Int) (common.Address, error) {
+	return _Vm.Contract.Addr(&_Vm.CallOpts, privateKey)
+}
+
+// Addr is a free data retrieval call binding the contract method 0xffa18649.
+//
+// Solidity: function addr(uint256 privateKey) pure returns(address keyAddr)
+func (_Vm *VmCallerSession) Addr(privateKey *big.Int) (common.Address, error) {
+	return _Vm.Contract.Addr(&_Vm.CallOpts, privateKey)
+}
+
+// AssertApproxEqAbs is a free data retrieval call binding the contract method 0x16d207c6.
+//
+// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) pure returns()
+func (_Vm *VmCaller) AssertApproxEqAbs(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqAbs", left, right, maxDelta)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbs is a free data retrieval call binding the contract method 0x16d207c6.
+//
+// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) pure returns()
+func (_Vm *VmSession) AssertApproxEqAbs(left *big.Int, right *big.Int, maxDelta *big.Int) error {
+	return _Vm.Contract.AssertApproxEqAbs(&_Vm.CallOpts, left, right, maxDelta)
+}
+
+// AssertApproxEqAbs is a free data retrieval call binding the contract method 0x16d207c6.
+//
+// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqAbs(left *big.Int, right *big.Int, maxDelta *big.Int) error {
+	return _Vm.Contract.AssertApproxEqAbs(&_Vm.CallOpts, left, right, maxDelta)
+}
+
+// AssertApproxEqAbs0 is a free data retrieval call binding the contract method 0x240f839d.
+//
+// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) pure returns()
+func (_Vm *VmCaller) AssertApproxEqAbs0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqAbs0", left, right, maxDelta)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbs0 is a free data retrieval call binding the contract method 0x240f839d.
+//
+// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) pure returns()
+func (_Vm *VmSession) AssertApproxEqAbs0(left *big.Int, right *big.Int, maxDelta *big.Int) error {
+	return _Vm.Contract.AssertApproxEqAbs0(&_Vm.CallOpts, left, right, maxDelta)
+}
+
+// AssertApproxEqAbs0 is a free data retrieval call binding the contract method 0x240f839d.
+//
+// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqAbs0(left *big.Int, right *big.Int, maxDelta *big.Int) error {
+	return _Vm.Contract.AssertApproxEqAbs0(&_Vm.CallOpts, left, right, maxDelta)
+}
+
+// AssertApproxEqAbs1 is a free data retrieval call binding the contract method 0x8289e621.
+//
+// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string error) pure returns()
+func (_Vm *VmCaller) AssertApproxEqAbs1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqAbs1", left, right, maxDelta, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbs1 is a free data retrieval call binding the contract method 0x8289e621.
+//
+// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string error) pure returns()
+func (_Vm *VmSession) AssertApproxEqAbs1(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqAbs1(&_Vm.CallOpts, left, right, maxDelta, error)
+}
+
+// AssertApproxEqAbs1 is a free data retrieval call binding the contract method 0x8289e621.
+//
+// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string error) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqAbs1(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqAbs1(&_Vm.CallOpts, left, right, maxDelta, error)
+}
+
+// AssertApproxEqAbs2 is a free data retrieval call binding the contract method 0xf710b062.
+//
+// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string error) pure returns()
+func (_Vm *VmCaller) AssertApproxEqAbs2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqAbs2", left, right, maxDelta, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbs2 is a free data retrieval call binding the contract method 0xf710b062.
+//
+// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string error) pure returns()
+func (_Vm *VmSession) AssertApproxEqAbs2(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqAbs2(&_Vm.CallOpts, left, right, maxDelta, error)
+}
+
+// AssertApproxEqAbs2 is a free data retrieval call binding the contract method 0xf710b062.
+//
+// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string error) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqAbs2(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqAbs2(&_Vm.CallOpts, left, right, maxDelta, error)
+}
+
+// AssertApproxEqAbsDecimal is a free data retrieval call binding the contract method 0x045c55ce.
+//
+// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertApproxEqAbsDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqAbsDecimal", left, right, maxDelta, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbsDecimal is a free data retrieval call binding the contract method 0x045c55ce.
+//
+// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertApproxEqAbsDecimal(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertApproxEqAbsDecimal(&_Vm.CallOpts, left, right, maxDelta, decimals)
+}
+
+// AssertApproxEqAbsDecimal is a free data retrieval call binding the contract method 0x045c55ce.
+//
+// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqAbsDecimal(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertApproxEqAbsDecimal(&_Vm.CallOpts, left, right, maxDelta, decimals)
+}
+
+// AssertApproxEqAbsDecimal0 is a free data retrieval call binding the contract method 0x3d5bc8bc.
+//
+// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertApproxEqAbsDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqAbsDecimal0", left, right, maxDelta, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbsDecimal0 is a free data retrieval call binding the contract method 0x3d5bc8bc.
+//
+// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertApproxEqAbsDecimal0(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertApproxEqAbsDecimal0(&_Vm.CallOpts, left, right, maxDelta, decimals)
+}
+
+// AssertApproxEqAbsDecimal0 is a free data retrieval call binding the contract method 0x3d5bc8bc.
+//
+// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqAbsDecimal0(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertApproxEqAbsDecimal0(&_Vm.CallOpts, left, right, maxDelta, decimals)
+}
+
+// AssertApproxEqAbsDecimal1 is a free data retrieval call binding the contract method 0x60429eb2.
+//
+// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertApproxEqAbsDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqAbsDecimal1", left, right, maxDelta, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbsDecimal1 is a free data retrieval call binding the contract method 0x60429eb2.
+//
+// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertApproxEqAbsDecimal1(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqAbsDecimal1(&_Vm.CallOpts, left, right, maxDelta, decimals, error)
+}
+
+// AssertApproxEqAbsDecimal1 is a free data retrieval call binding the contract method 0x60429eb2.
+//
+// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqAbsDecimal1(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqAbsDecimal1(&_Vm.CallOpts, left, right, maxDelta, decimals, error)
+}
+
+// AssertApproxEqAbsDecimal2 is a free data retrieval call binding the contract method 0x6a5066d4.
+//
+// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertApproxEqAbsDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqAbsDecimal2", left, right, maxDelta, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbsDecimal2 is a free data retrieval call binding the contract method 0x6a5066d4.
+//
+// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertApproxEqAbsDecimal2(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqAbsDecimal2(&_Vm.CallOpts, left, right, maxDelta, decimals, error)
+}
+
+// AssertApproxEqAbsDecimal2 is a free data retrieval call binding the contract method 0x6a5066d4.
+//
+// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqAbsDecimal2(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqAbsDecimal2(&_Vm.CallOpts, left, right, maxDelta, decimals, error)
+}
+
+// AssertApproxEqRel is a free data retrieval call binding the contract method 0x1ecb7d33.
+//
+// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string error) pure returns()
+func (_Vm *VmCaller) AssertApproxEqRel(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqRel", left, right, maxPercentDelta, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRel is a free data retrieval call binding the contract method 0x1ecb7d33.
+//
+// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string error) pure returns()
+func (_Vm *VmSession) AssertApproxEqRel(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqRel(&_Vm.CallOpts, left, right, maxPercentDelta, error)
+}
+
+// AssertApproxEqRel is a free data retrieval call binding the contract method 0x1ecb7d33.
+//
+// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string error) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqRel(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqRel(&_Vm.CallOpts, left, right, maxPercentDelta, error)
+}
+
+// AssertApproxEqRel0 is a free data retrieval call binding the contract method 0x8cf25ef4.
+//
+// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) pure returns()
+func (_Vm *VmCaller) AssertApproxEqRel0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqRel0", left, right, maxPercentDelta)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRel0 is a free data retrieval call binding the contract method 0x8cf25ef4.
+//
+// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) pure returns()
+func (_Vm *VmSession) AssertApproxEqRel0(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error {
+	return _Vm.Contract.AssertApproxEqRel0(&_Vm.CallOpts, left, right, maxPercentDelta)
+}
+
+// AssertApproxEqRel0 is a free data retrieval call binding the contract method 0x8cf25ef4.
+//
+// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqRel0(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error {
+	return _Vm.Contract.AssertApproxEqRel0(&_Vm.CallOpts, left, right, maxPercentDelta)
+}
+
+// AssertApproxEqRel1 is a free data retrieval call binding the contract method 0xef277d72.
+//
+// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string error) pure returns()
+func (_Vm *VmCaller) AssertApproxEqRel1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqRel1", left, right, maxPercentDelta, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRel1 is a free data retrieval call binding the contract method 0xef277d72.
+//
+// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string error) pure returns()
+func (_Vm *VmSession) AssertApproxEqRel1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqRel1(&_Vm.CallOpts, left, right, maxPercentDelta, error)
+}
+
+// AssertApproxEqRel1 is a free data retrieval call binding the contract method 0xef277d72.
+//
+// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string error) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqRel1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqRel1(&_Vm.CallOpts, left, right, maxPercentDelta, error)
+}
+
+// AssertApproxEqRel2 is a free data retrieval call binding the contract method 0xfea2d14f.
+//
+// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) pure returns()
+func (_Vm *VmCaller) AssertApproxEqRel2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqRel2", left, right, maxPercentDelta)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRel2 is a free data retrieval call binding the contract method 0xfea2d14f.
+//
+// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) pure returns()
+func (_Vm *VmSession) AssertApproxEqRel2(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error {
+	return _Vm.Contract.AssertApproxEqRel2(&_Vm.CallOpts, left, right, maxPercentDelta)
+}
+
+// AssertApproxEqRel2 is a free data retrieval call binding the contract method 0xfea2d14f.
+//
+// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqRel2(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error {
+	return _Vm.Contract.AssertApproxEqRel2(&_Vm.CallOpts, left, right, maxPercentDelta)
+}
+
+// AssertApproxEqRelDecimal is a free data retrieval call binding the contract method 0x21ed2977.
+//
+// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertApproxEqRelDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqRelDecimal", left, right, maxPercentDelta, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRelDecimal is a free data retrieval call binding the contract method 0x21ed2977.
+//
+// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertApproxEqRelDecimal(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertApproxEqRelDecimal(&_Vm.CallOpts, left, right, maxPercentDelta, decimals)
+}
+
+// AssertApproxEqRelDecimal is a free data retrieval call binding the contract method 0x21ed2977.
+//
+// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqRelDecimal(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertApproxEqRelDecimal(&_Vm.CallOpts, left, right, maxPercentDelta, decimals)
+}
+
+// AssertApproxEqRelDecimal0 is a free data retrieval call binding the contract method 0x82d6c8fd.
+//
+// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertApproxEqRelDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqRelDecimal0", left, right, maxPercentDelta, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRelDecimal0 is a free data retrieval call binding the contract method 0x82d6c8fd.
+//
+// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertApproxEqRelDecimal0(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqRelDecimal0(&_Vm.CallOpts, left, right, maxPercentDelta, decimals, error)
+}
+
+// AssertApproxEqRelDecimal0 is a free data retrieval call binding the contract method 0x82d6c8fd.
+//
+// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqRelDecimal0(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqRelDecimal0(&_Vm.CallOpts, left, right, maxPercentDelta, decimals, error)
+}
+
+// AssertApproxEqRelDecimal1 is a free data retrieval call binding the contract method 0xabbf21cc.
+//
+// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertApproxEqRelDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqRelDecimal1", left, right, maxPercentDelta, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRelDecimal1 is a free data retrieval call binding the contract method 0xabbf21cc.
+//
+// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertApproxEqRelDecimal1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertApproxEqRelDecimal1(&_Vm.CallOpts, left, right, maxPercentDelta, decimals)
+}
+
+// AssertApproxEqRelDecimal1 is a free data retrieval call binding the contract method 0xabbf21cc.
+//
+// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqRelDecimal1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertApproxEqRelDecimal1(&_Vm.CallOpts, left, right, maxPercentDelta, decimals)
+}
+
+// AssertApproxEqRelDecimal2 is a free data retrieval call binding the contract method 0xfccc11c4.
+//
+// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertApproxEqRelDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertApproxEqRelDecimal2", left, right, maxPercentDelta, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRelDecimal2 is a free data retrieval call binding the contract method 0xfccc11c4.
+//
+// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertApproxEqRelDecimal2(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqRelDecimal2(&_Vm.CallOpts, left, right, maxPercentDelta, decimals, error)
+}
+
+// AssertApproxEqRelDecimal2 is a free data retrieval call binding the contract method 0xfccc11c4.
+//
+// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertApproxEqRelDecimal2(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertApproxEqRelDecimal2(&_Vm.CallOpts, left, right, maxPercentDelta, decimals, error)
+}
+
+// AssertEq is a free data retrieval call binding the contract method 0x0cc9ee84.
+//
+// Solidity: function assertEq(bytes32[] left, bytes32[] right) pure returns()
+func (_Vm *VmCaller) AssertEq(opts *bind.CallOpts, left [][32]byte, right [][32]byte) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq is a free data retrieval call binding the contract method 0x0cc9ee84.
+//
+// Solidity: function assertEq(bytes32[] left, bytes32[] right) pure returns()
+func (_Vm *VmSession) AssertEq(left [][32]byte, right [][32]byte) error {
+	return _Vm.Contract.AssertEq(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq is a free data retrieval call binding the contract method 0x0cc9ee84.
+//
+// Solidity: function assertEq(bytes32[] left, bytes32[] right) pure returns()
+func (_Vm *VmCallerSession) AssertEq(left [][32]byte, right [][32]byte) error {
+	return _Vm.Contract.AssertEq(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq0 is a free data retrieval call binding the contract method 0x191f1b30.
+//
+// Solidity: function assertEq(int256[] left, int256[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq0(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq0", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq0 is a free data retrieval call binding the contract method 0x191f1b30.
+//
+// Solidity: function assertEq(int256[] left, int256[] right, string error) pure returns()
+func (_Vm *VmSession) AssertEq0(left []*big.Int, right []*big.Int, error string) error {
+	return _Vm.Contract.AssertEq0(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq0 is a free data retrieval call binding the contract method 0x191f1b30.
+//
+// Solidity: function assertEq(int256[] left, int256[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq0(left []*big.Int, right []*big.Int, error string) error {
+	return _Vm.Contract.AssertEq0(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq1 is a free data retrieval call binding the contract method 0x2f2769d1.
+//
+// Solidity: function assertEq(address left, address right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq1(opts *bind.CallOpts, left common.Address, right common.Address, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq1", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq1 is a free data retrieval call binding the contract method 0x2f2769d1.
+//
+// Solidity: function assertEq(address left, address right, string error) pure returns()
+func (_Vm *VmSession) AssertEq1(left common.Address, right common.Address, error string) error {
+	return _Vm.Contract.AssertEq1(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq1 is a free data retrieval call binding the contract method 0x2f2769d1.
+//
+// Solidity: function assertEq(address left, address right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq1(left common.Address, right common.Address, error string) error {
+	return _Vm.Contract.AssertEq1(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq10 is a free data retrieval call binding the contract method 0x714a2f13.
+//
+// Solidity: function assertEq(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq10(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq10", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq10 is a free data retrieval call binding the contract method 0x714a2f13.
+//
+// Solidity: function assertEq(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmSession) AssertEq10(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertEq10(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq10 is a free data retrieval call binding the contract method 0x714a2f13.
+//
+// Solidity: function assertEq(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq10(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertEq10(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq11 is a free data retrieval call binding the contract method 0x7c84c69b.
+//
+// Solidity: function assertEq(bytes32 left, bytes32 right) pure returns()
+func (_Vm *VmCaller) AssertEq11(opts *bind.CallOpts, left [32]byte, right [32]byte) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq11", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq11 is a free data retrieval call binding the contract method 0x7c84c69b.
+//
+// Solidity: function assertEq(bytes32 left, bytes32 right) pure returns()
+func (_Vm *VmSession) AssertEq11(left [32]byte, right [32]byte) error {
+	return _Vm.Contract.AssertEq11(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq11 is a free data retrieval call binding the contract method 0x7c84c69b.
+//
+// Solidity: function assertEq(bytes32 left, bytes32 right) pure returns()
+func (_Vm *VmCallerSession) AssertEq11(left [32]byte, right [32]byte) error {
+	return _Vm.Contract.AssertEq11(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq12 is a free data retrieval call binding the contract method 0x88b44c85.
+//
+// Solidity: function assertEq(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq12(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq12", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq12 is a free data retrieval call binding the contract method 0x88b44c85.
+//
+// Solidity: function assertEq(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmSession) AssertEq12(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertEq12(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq12 is a free data retrieval call binding the contract method 0x88b44c85.
+//
+// Solidity: function assertEq(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq12(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertEq12(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq13 is a free data retrieval call binding the contract method 0x975d5a12.
+//
+// Solidity: function assertEq(uint256[] left, uint256[] right) pure returns()
+func (_Vm *VmCaller) AssertEq13(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq13", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq13 is a free data retrieval call binding the contract method 0x975d5a12.
+//
+// Solidity: function assertEq(uint256[] left, uint256[] right) pure returns()
+func (_Vm *VmSession) AssertEq13(left []*big.Int, right []*big.Int) error {
+	return _Vm.Contract.AssertEq13(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq13 is a free data retrieval call binding the contract method 0x975d5a12.
+//
+// Solidity: function assertEq(uint256[] left, uint256[] right) pure returns()
+func (_Vm *VmCallerSession) AssertEq13(left []*big.Int, right []*big.Int) error {
+	return _Vm.Contract.AssertEq13(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq14 is a free data retrieval call binding the contract method 0x97624631.
+//
+// Solidity: function assertEq(bytes left, bytes right) pure returns()
+func (_Vm *VmCaller) AssertEq14(opts *bind.CallOpts, left []byte, right []byte) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq14", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq14 is a free data retrieval call binding the contract method 0x97624631.
+//
+// Solidity: function assertEq(bytes left, bytes right) pure returns()
+func (_Vm *VmSession) AssertEq14(left []byte, right []byte) error {
+	return _Vm.Contract.AssertEq14(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq14 is a free data retrieval call binding the contract method 0x97624631.
+//
+// Solidity: function assertEq(bytes left, bytes right) pure returns()
+func (_Vm *VmCallerSession) AssertEq14(left []byte, right []byte) error {
+	return _Vm.Contract.AssertEq14(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq15 is a free data retrieval call binding the contract method 0x98296c54.
+//
+// Solidity: function assertEq(uint256 left, uint256 right) pure returns()
+func (_Vm *VmCaller) AssertEq15(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq15", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq15 is a free data retrieval call binding the contract method 0x98296c54.
+//
+// Solidity: function assertEq(uint256 left, uint256 right) pure returns()
+func (_Vm *VmSession) AssertEq15(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertEq15(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq15 is a free data retrieval call binding the contract method 0x98296c54.
+//
+// Solidity: function assertEq(uint256 left, uint256 right) pure returns()
+func (_Vm *VmCallerSession) AssertEq15(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertEq15(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq16 is a free data retrieval call binding the contract method 0xc1fa1ed0.
+//
+// Solidity: function assertEq(bytes32 left, bytes32 right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq16(opts *bind.CallOpts, left [32]byte, right [32]byte, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq16", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq16 is a free data retrieval call binding the contract method 0xc1fa1ed0.
+//
+// Solidity: function assertEq(bytes32 left, bytes32 right, string error) pure returns()
+func (_Vm *VmSession) AssertEq16(left [32]byte, right [32]byte, error string) error {
+	return _Vm.Contract.AssertEq16(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq16 is a free data retrieval call binding the contract method 0xc1fa1ed0.
+//
+// Solidity: function assertEq(bytes32 left, bytes32 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq16(left [32]byte, right [32]byte, error string) error {
+	return _Vm.Contract.AssertEq16(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq17 is a free data retrieval call binding the contract method 0xcf1c049c.
+//
+// Solidity: function assertEq(string[] left, string[] right) pure returns()
+func (_Vm *VmCaller) AssertEq17(opts *bind.CallOpts, left []string, right []string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq17", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq17 is a free data retrieval call binding the contract method 0xcf1c049c.
+//
+// Solidity: function assertEq(string[] left, string[] right) pure returns()
+func (_Vm *VmSession) AssertEq17(left []string, right []string) error {
+	return _Vm.Contract.AssertEq17(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq17 is a free data retrieval call binding the contract method 0xcf1c049c.
+//
+// Solidity: function assertEq(string[] left, string[] right) pure returns()
+func (_Vm *VmCallerSession) AssertEq17(left []string, right []string) error {
+	return _Vm.Contract.AssertEq17(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq18 is a free data retrieval call binding the contract method 0xe03e9177.
+//
+// Solidity: function assertEq(bytes32[] left, bytes32[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq18(opts *bind.CallOpts, left [][32]byte, right [][32]byte, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq18", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq18 is a free data retrieval call binding the contract method 0xe03e9177.
+//
+// Solidity: function assertEq(bytes32[] left, bytes32[] right, string error) pure returns()
+func (_Vm *VmSession) AssertEq18(left [][32]byte, right [][32]byte, error string) error {
+	return _Vm.Contract.AssertEq18(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq18 is a free data retrieval call binding the contract method 0xe03e9177.
+//
+// Solidity: function assertEq(bytes32[] left, bytes32[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq18(left [][32]byte, right [][32]byte, error string) error {
+	return _Vm.Contract.AssertEq18(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq19 is a free data retrieval call binding the contract method 0xe24fed00.
+//
+// Solidity: function assertEq(bytes left, bytes right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq19(opts *bind.CallOpts, left []byte, right []byte, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq19", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq19 is a free data retrieval call binding the contract method 0xe24fed00.
+//
+// Solidity: function assertEq(bytes left, bytes right, string error) pure returns()
+func (_Vm *VmSession) AssertEq19(left []byte, right []byte, error string) error {
+	return _Vm.Contract.AssertEq19(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq19 is a free data retrieval call binding the contract method 0xe24fed00.
+//
+// Solidity: function assertEq(bytes left, bytes right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq19(left []byte, right []byte, error string) error {
+	return _Vm.Contract.AssertEq19(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq2 is a free data retrieval call binding the contract method 0x36f656d8.
+//
+// Solidity: function assertEq(string left, string right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq2(opts *bind.CallOpts, left string, right string, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq2", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq2 is a free data retrieval call binding the contract method 0x36f656d8.
+//
+// Solidity: function assertEq(string left, string right, string error) pure returns()
+func (_Vm *VmSession) AssertEq2(left string, right string, error string) error {
+	return _Vm.Contract.AssertEq2(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq2 is a free data retrieval call binding the contract method 0x36f656d8.
+//
+// Solidity: function assertEq(string left, string right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq2(left string, right string, error string) error {
+	return _Vm.Contract.AssertEq2(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq20 is a free data retrieval call binding the contract method 0xe48a8f8d.
+//
+// Solidity: function assertEq(bool[] left, bool[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq20(opts *bind.CallOpts, left []bool, right []bool, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq20", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq20 is a free data retrieval call binding the contract method 0xe48a8f8d.
+//
+// Solidity: function assertEq(bool[] left, bool[] right, string error) pure returns()
+func (_Vm *VmSession) AssertEq20(left []bool, right []bool, error string) error {
+	return _Vm.Contract.AssertEq20(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq20 is a free data retrieval call binding the contract method 0xe48a8f8d.
+//
+// Solidity: function assertEq(bool[] left, bool[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq20(left []bool, right []bool, error string) error {
+	return _Vm.Contract.AssertEq20(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq21 is a free data retrieval call binding the contract method 0xe5fb9b4a.
+//
+// Solidity: function assertEq(bytes[] left, bytes[] right) pure returns()
+func (_Vm *VmCaller) AssertEq21(opts *bind.CallOpts, left [][]byte, right [][]byte) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq21", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq21 is a free data retrieval call binding the contract method 0xe5fb9b4a.
+//
+// Solidity: function assertEq(bytes[] left, bytes[] right) pure returns()
+func (_Vm *VmSession) AssertEq21(left [][]byte, right [][]byte) error {
+	return _Vm.Contract.AssertEq21(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq21 is a free data retrieval call binding the contract method 0xe5fb9b4a.
+//
+// Solidity: function assertEq(bytes[] left, bytes[] right) pure returns()
+func (_Vm *VmCallerSession) AssertEq21(left [][]byte, right [][]byte) error {
+	return _Vm.Contract.AssertEq21(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq22 is a free data retrieval call binding the contract method 0xeff6b27d.
+//
+// Solidity: function assertEq(string[] left, string[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq22(opts *bind.CallOpts, left []string, right []string, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq22", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq22 is a free data retrieval call binding the contract method 0xeff6b27d.
+//
+// Solidity: function assertEq(string[] left, string[] right, string error) pure returns()
+func (_Vm *VmSession) AssertEq22(left []string, right []string, error string) error {
+	return _Vm.Contract.AssertEq22(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq22 is a free data retrieval call binding the contract method 0xeff6b27d.
+//
+// Solidity: function assertEq(string[] left, string[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq22(left []string, right []string, error string) error {
+	return _Vm.Contract.AssertEq22(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq23 is a free data retrieval call binding the contract method 0xf320d963.
+//
+// Solidity: function assertEq(string left, string right) pure returns()
+func (_Vm *VmCaller) AssertEq23(opts *bind.CallOpts, left string, right string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq23", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq23 is a free data retrieval call binding the contract method 0xf320d963.
+//
+// Solidity: function assertEq(string left, string right) pure returns()
+func (_Vm *VmSession) AssertEq23(left string, right string) error {
+	return _Vm.Contract.AssertEq23(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq23 is a free data retrieval call binding the contract method 0xf320d963.
+//
+// Solidity: function assertEq(string left, string right) pure returns()
+func (_Vm *VmCallerSession) AssertEq23(left string, right string) error {
+	return _Vm.Contract.AssertEq23(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq24 is a free data retrieval call binding the contract method 0xf413f0b6.
+//
+// Solidity: function assertEq(bytes[] left, bytes[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq24(opts *bind.CallOpts, left [][]byte, right [][]byte, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq24", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq24 is a free data retrieval call binding the contract method 0xf413f0b6.
+//
+// Solidity: function assertEq(bytes[] left, bytes[] right, string error) pure returns()
+func (_Vm *VmSession) AssertEq24(left [][]byte, right [][]byte, error string) error {
+	return _Vm.Contract.AssertEq24(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq24 is a free data retrieval call binding the contract method 0xf413f0b6.
+//
+// Solidity: function assertEq(bytes[] left, bytes[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq24(left [][]byte, right [][]byte, error string) error {
+	return _Vm.Contract.AssertEq24(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq25 is a free data retrieval call binding the contract method 0xf7fe3477.
+//
+// Solidity: function assertEq(bool left, bool right) pure returns()
+func (_Vm *VmCaller) AssertEq25(opts *bind.CallOpts, left bool, right bool) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq25", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq25 is a free data retrieval call binding the contract method 0xf7fe3477.
+//
+// Solidity: function assertEq(bool left, bool right) pure returns()
+func (_Vm *VmSession) AssertEq25(left bool, right bool) error {
+	return _Vm.Contract.AssertEq25(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq25 is a free data retrieval call binding the contract method 0xf7fe3477.
+//
+// Solidity: function assertEq(bool left, bool right) pure returns()
+func (_Vm *VmCallerSession) AssertEq25(left bool, right bool) error {
+	return _Vm.Contract.AssertEq25(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq26 is a free data retrieval call binding the contract method 0xfe74f05b.
+//
+// Solidity: function assertEq(int256 left, int256 right) pure returns()
+func (_Vm *VmCaller) AssertEq26(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq26", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq26 is a free data retrieval call binding the contract method 0xfe74f05b.
+//
+// Solidity: function assertEq(int256 left, int256 right) pure returns()
+func (_Vm *VmSession) AssertEq26(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertEq26(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq26 is a free data retrieval call binding the contract method 0xfe74f05b.
+//
+// Solidity: function assertEq(int256 left, int256 right) pure returns()
+func (_Vm *VmCallerSession) AssertEq26(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertEq26(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq3 is a free data retrieval call binding the contract method 0x3868ac34.
+//
+// Solidity: function assertEq(address[] left, address[] right) pure returns()
+func (_Vm *VmCaller) AssertEq3(opts *bind.CallOpts, left []common.Address, right []common.Address) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq3", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq3 is a free data retrieval call binding the contract method 0x3868ac34.
+//
+// Solidity: function assertEq(address[] left, address[] right) pure returns()
+func (_Vm *VmSession) AssertEq3(left []common.Address, right []common.Address) error {
+	return _Vm.Contract.AssertEq3(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq3 is a free data retrieval call binding the contract method 0x3868ac34.
+//
+// Solidity: function assertEq(address[] left, address[] right) pure returns()
+func (_Vm *VmCallerSession) AssertEq3(left []common.Address, right []common.Address) error {
+	return _Vm.Contract.AssertEq3(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq4 is a free data retrieval call binding the contract method 0x3e9173c5.
+//
+// Solidity: function assertEq(address[] left, address[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq4(opts *bind.CallOpts, left []common.Address, right []common.Address, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq4", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq4 is a free data retrieval call binding the contract method 0x3e9173c5.
+//
+// Solidity: function assertEq(address[] left, address[] right, string error) pure returns()
+func (_Vm *VmSession) AssertEq4(left []common.Address, right []common.Address, error string) error {
+	return _Vm.Contract.AssertEq4(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq4 is a free data retrieval call binding the contract method 0x3e9173c5.
+//
+// Solidity: function assertEq(address[] left, address[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq4(left []common.Address, right []common.Address, error string) error {
+	return _Vm.Contract.AssertEq4(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq5 is a free data retrieval call binding the contract method 0x4db19e7e.
+//
+// Solidity: function assertEq(bool left, bool right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq5(opts *bind.CallOpts, left bool, right bool, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq5", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq5 is a free data retrieval call binding the contract method 0x4db19e7e.
+//
+// Solidity: function assertEq(bool left, bool right, string error) pure returns()
+func (_Vm *VmSession) AssertEq5(left bool, right bool, error string) error {
+	return _Vm.Contract.AssertEq5(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq5 is a free data retrieval call binding the contract method 0x4db19e7e.
+//
+// Solidity: function assertEq(bool left, bool right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq5(left bool, right bool, error string) error {
+	return _Vm.Contract.AssertEq5(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq6 is a free data retrieval call binding the contract method 0x515361f6.
+//
+// Solidity: function assertEq(address left, address right) pure returns()
+func (_Vm *VmCaller) AssertEq6(opts *bind.CallOpts, left common.Address, right common.Address) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq6", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq6 is a free data retrieval call binding the contract method 0x515361f6.
+//
+// Solidity: function assertEq(address left, address right) pure returns()
+func (_Vm *VmSession) AssertEq6(left common.Address, right common.Address) error {
+	return _Vm.Contract.AssertEq6(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq6 is a free data retrieval call binding the contract method 0x515361f6.
+//
+// Solidity: function assertEq(address left, address right) pure returns()
+func (_Vm *VmCallerSession) AssertEq6(left common.Address, right common.Address) error {
+	return _Vm.Contract.AssertEq6(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq7 is a free data retrieval call binding the contract method 0x5d18c73a.
+//
+// Solidity: function assertEq(uint256[] left, uint256[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertEq7(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq7", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq7 is a free data retrieval call binding the contract method 0x5d18c73a.
+//
+// Solidity: function assertEq(uint256[] left, uint256[] right, string error) pure returns()
+func (_Vm *VmSession) AssertEq7(left []*big.Int, right []*big.Int, error string) error {
+	return _Vm.Contract.AssertEq7(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq7 is a free data retrieval call binding the contract method 0x5d18c73a.
+//
+// Solidity: function assertEq(uint256[] left, uint256[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEq7(left []*big.Int, right []*big.Int, error string) error {
+	return _Vm.Contract.AssertEq7(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertEq8 is a free data retrieval call binding the contract method 0x707df785.
+//
+// Solidity: function assertEq(bool[] left, bool[] right) pure returns()
+func (_Vm *VmCaller) AssertEq8(opts *bind.CallOpts, left []bool, right []bool) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq8", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq8 is a free data retrieval call binding the contract method 0x707df785.
+//
+// Solidity: function assertEq(bool[] left, bool[] right) pure returns()
+func (_Vm *VmSession) AssertEq8(left []bool, right []bool) error {
+	return _Vm.Contract.AssertEq8(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq8 is a free data retrieval call binding the contract method 0x707df785.
+//
+// Solidity: function assertEq(bool[] left, bool[] right) pure returns()
+func (_Vm *VmCallerSession) AssertEq8(left []bool, right []bool) error {
+	return _Vm.Contract.AssertEq8(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq9 is a free data retrieval call binding the contract method 0x711043ac.
+//
+// Solidity: function assertEq(int256[] left, int256[] right) pure returns()
+func (_Vm *VmCaller) AssertEq9(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEq9", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq9 is a free data retrieval call binding the contract method 0x711043ac.
+//
+// Solidity: function assertEq(int256[] left, int256[] right) pure returns()
+func (_Vm *VmSession) AssertEq9(left []*big.Int, right []*big.Int) error {
+	return _Vm.Contract.AssertEq9(&_Vm.CallOpts, left, right)
+}
+
+// AssertEq9 is a free data retrieval call binding the contract method 0x711043ac.
+//
+// Solidity: function assertEq(int256[] left, int256[] right) pure returns()
+func (_Vm *VmCallerSession) AssertEq9(left []*big.Int, right []*big.Int) error {
+	return _Vm.Contract.AssertEq9(&_Vm.CallOpts, left, right)
+}
+
+// AssertEqDecimal is a free data retrieval call binding the contract method 0x27af7d9c.
+//
+// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertEqDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEqDecimal", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEqDecimal is a free data retrieval call binding the contract method 0x27af7d9c.
+//
+// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertEqDecimal(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertEqDecimal is a free data retrieval call binding the contract method 0x27af7d9c.
+//
+// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertEqDecimal(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertEqDecimal0 is a free data retrieval call binding the contract method 0x48016c04.
+//
+// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertEqDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEqDecimal0", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEqDecimal0 is a free data retrieval call binding the contract method 0x48016c04.
+//
+// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertEqDecimal0(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertEqDecimal0 is a free data retrieval call binding the contract method 0x48016c04.
+//
+// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertEqDecimal0(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertEqDecimal1 is a free data retrieval call binding the contract method 0x7e77b0c5.
+//
+// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertEqDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEqDecimal1", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEqDecimal1 is a free data retrieval call binding the contract method 0x7e77b0c5.
+//
+// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertEqDecimal1(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertEqDecimal1 is a free data retrieval call binding the contract method 0x7e77b0c5.
+//
+// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertEqDecimal1(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertEqDecimal2 is a free data retrieval call binding the contract method 0xd0cbbdef.
+//
+// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertEqDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertEqDecimal2", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEqDecimal2 is a free data retrieval call binding the contract method 0xd0cbbdef.
+//
+// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertEqDecimal2(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertEqDecimal2 is a free data retrieval call binding the contract method 0xd0cbbdef.
+//
+// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertEqDecimal2(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertFalse is a free data retrieval call binding the contract method 0x7ba04809.
+//
+// Solidity: function assertFalse(bool condition, string error) pure returns()
+func (_Vm *VmCaller) AssertFalse(opts *bind.CallOpts, condition bool, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertFalse", condition, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertFalse is a free data retrieval call binding the contract method 0x7ba04809.
+//
+// Solidity: function assertFalse(bool condition, string error) pure returns()
+func (_Vm *VmSession) AssertFalse(condition bool, error string) error {
+	return _Vm.Contract.AssertFalse(&_Vm.CallOpts, condition, error)
+}
+
+// AssertFalse is a free data retrieval call binding the contract method 0x7ba04809.
+//
+// Solidity: function assertFalse(bool condition, string error) pure returns()
+func (_Vm *VmCallerSession) AssertFalse(condition bool, error string) error {
+	return _Vm.Contract.AssertFalse(&_Vm.CallOpts, condition, error)
+}
+
+// AssertFalse0 is a free data retrieval call binding the contract method 0xa5982885.
+//
+// Solidity: function assertFalse(bool condition) pure returns()
+func (_Vm *VmCaller) AssertFalse0(opts *bind.CallOpts, condition bool) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertFalse0", condition)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertFalse0 is a free data retrieval call binding the contract method 0xa5982885.
+//
+// Solidity: function assertFalse(bool condition) pure returns()
+func (_Vm *VmSession) AssertFalse0(condition bool) error {
+	return _Vm.Contract.AssertFalse0(&_Vm.CallOpts, condition)
+}
+
+// AssertFalse0 is a free data retrieval call binding the contract method 0xa5982885.
+//
+// Solidity: function assertFalse(bool condition) pure returns()
+func (_Vm *VmCallerSession) AssertFalse0(condition bool) error {
+	return _Vm.Contract.AssertFalse0(&_Vm.CallOpts, condition)
+}
+
+// AssertGe is a free data retrieval call binding the contract method 0x0a30b771.
+//
+// Solidity: function assertGe(int256 left, int256 right) pure returns()
+func (_Vm *VmCaller) AssertGe(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGe", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGe is a free data retrieval call binding the contract method 0x0a30b771.
+//
+// Solidity: function assertGe(int256 left, int256 right) pure returns()
+func (_Vm *VmSession) AssertGe(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertGe(&_Vm.CallOpts, left, right)
+}
+
+// AssertGe is a free data retrieval call binding the contract method 0x0a30b771.
+//
+// Solidity: function assertGe(int256 left, int256 right) pure returns()
+func (_Vm *VmCallerSession) AssertGe(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertGe(&_Vm.CallOpts, left, right)
+}
+
+// AssertGe0 is a free data retrieval call binding the contract method 0xa84328dd.
+//
+// Solidity: function assertGe(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmCaller) AssertGe0(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGe0", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGe0 is a free data retrieval call binding the contract method 0xa84328dd.
+//
+// Solidity: function assertGe(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmSession) AssertGe0(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertGe0(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertGe0 is a free data retrieval call binding the contract method 0xa84328dd.
+//
+// Solidity: function assertGe(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertGe0(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertGe0(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertGe1 is a free data retrieval call binding the contract method 0xa8d4d1d9.
+//
+// Solidity: function assertGe(uint256 left, uint256 right) pure returns()
+func (_Vm *VmCaller) AssertGe1(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGe1", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGe1 is a free data retrieval call binding the contract method 0xa8d4d1d9.
+//
+// Solidity: function assertGe(uint256 left, uint256 right) pure returns()
+func (_Vm *VmSession) AssertGe1(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertGe1(&_Vm.CallOpts, left, right)
+}
+
+// AssertGe1 is a free data retrieval call binding the contract method 0xa8d4d1d9.
+//
+// Solidity: function assertGe(uint256 left, uint256 right) pure returns()
+func (_Vm *VmCallerSession) AssertGe1(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertGe1(&_Vm.CallOpts, left, right)
+}
+
+// AssertGe2 is a free data retrieval call binding the contract method 0xe25242c0.
+//
+// Solidity: function assertGe(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmCaller) AssertGe2(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGe2", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGe2 is a free data retrieval call binding the contract method 0xe25242c0.
+//
+// Solidity: function assertGe(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmSession) AssertGe2(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertGe2(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertGe2 is a free data retrieval call binding the contract method 0xe25242c0.
+//
+// Solidity: function assertGe(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertGe2(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertGe2(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertGeDecimal is a free data retrieval call binding the contract method 0x3d1fe08a.
+//
+// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertGeDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGeDecimal", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGeDecimal is a free data retrieval call binding the contract method 0x3d1fe08a.
+//
+// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertGeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertGeDecimal(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertGeDecimal is a free data retrieval call binding the contract method 0x3d1fe08a.
+//
+// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertGeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertGeDecimal(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertGeDecimal0 is a free data retrieval call binding the contract method 0x5df93c9b.
+//
+// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertGeDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGeDecimal0", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGeDecimal0 is a free data retrieval call binding the contract method 0x5df93c9b.
+//
+// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertGeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertGeDecimal0(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertGeDecimal0 is a free data retrieval call binding the contract method 0x5df93c9b.
+//
+// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertGeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertGeDecimal0(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertGeDecimal1 is a free data retrieval call binding the contract method 0x8bff9133.
+//
+// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertGeDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGeDecimal1", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGeDecimal1 is a free data retrieval call binding the contract method 0x8bff9133.
+//
+// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertGeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertGeDecimal1(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertGeDecimal1 is a free data retrieval call binding the contract method 0x8bff9133.
+//
+// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertGeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertGeDecimal1(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertGeDecimal2 is a free data retrieval call binding the contract method 0xdc28c0f1.
+//
+// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertGeDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGeDecimal2", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGeDecimal2 is a free data retrieval call binding the contract method 0xdc28c0f1.
+//
+// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertGeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertGeDecimal2(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertGeDecimal2 is a free data retrieval call binding the contract method 0xdc28c0f1.
+//
+// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertGeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertGeDecimal2(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertGt is a free data retrieval call binding the contract method 0x5a362d45.
+//
+// Solidity: function assertGt(int256 left, int256 right) pure returns()
+func (_Vm *VmCaller) AssertGt(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGt", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGt is a free data retrieval call binding the contract method 0x5a362d45.
+//
+// Solidity: function assertGt(int256 left, int256 right) pure returns()
+func (_Vm *VmSession) AssertGt(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertGt(&_Vm.CallOpts, left, right)
+}
+
+// AssertGt is a free data retrieval call binding the contract method 0x5a362d45.
+//
+// Solidity: function assertGt(int256 left, int256 right) pure returns()
+func (_Vm *VmCallerSession) AssertGt(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertGt(&_Vm.CallOpts, left, right)
+}
+
+// AssertGt0 is a free data retrieval call binding the contract method 0xd9a3c4d2.
+//
+// Solidity: function assertGt(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmCaller) AssertGt0(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGt0", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGt0 is a free data retrieval call binding the contract method 0xd9a3c4d2.
+//
+// Solidity: function assertGt(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmSession) AssertGt0(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertGt0(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertGt0 is a free data retrieval call binding the contract method 0xd9a3c4d2.
+//
+// Solidity: function assertGt(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertGt0(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertGt0(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertGt1 is a free data retrieval call binding the contract method 0xdb07fcd2.
+//
+// Solidity: function assertGt(uint256 left, uint256 right) pure returns()
+func (_Vm *VmCaller) AssertGt1(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGt1", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGt1 is a free data retrieval call binding the contract method 0xdb07fcd2.
+//
+// Solidity: function assertGt(uint256 left, uint256 right) pure returns()
+func (_Vm *VmSession) AssertGt1(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertGt1(&_Vm.CallOpts, left, right)
+}
+
+// AssertGt1 is a free data retrieval call binding the contract method 0xdb07fcd2.
+//
+// Solidity: function assertGt(uint256 left, uint256 right) pure returns()
+func (_Vm *VmCallerSession) AssertGt1(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertGt1(&_Vm.CallOpts, left, right)
+}
+
+// AssertGt2 is a free data retrieval call binding the contract method 0xf8d33b9b.
+//
+// Solidity: function assertGt(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmCaller) AssertGt2(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGt2", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGt2 is a free data retrieval call binding the contract method 0xf8d33b9b.
+//
+// Solidity: function assertGt(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmSession) AssertGt2(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertGt2(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertGt2 is a free data retrieval call binding the contract method 0xf8d33b9b.
+//
+// Solidity: function assertGt(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertGt2(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertGt2(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertGtDecimal is a free data retrieval call binding the contract method 0x04a5c7ab.
+//
+// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertGtDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGtDecimal", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGtDecimal is a free data retrieval call binding the contract method 0x04a5c7ab.
+//
+// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertGtDecimal(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertGtDecimal(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertGtDecimal is a free data retrieval call binding the contract method 0x04a5c7ab.
+//
+// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertGtDecimal(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertGtDecimal(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertGtDecimal0 is a free data retrieval call binding the contract method 0x64949a8d.
+//
+// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertGtDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGtDecimal0", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGtDecimal0 is a free data retrieval call binding the contract method 0x64949a8d.
+//
+// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertGtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertGtDecimal0(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertGtDecimal0 is a free data retrieval call binding the contract method 0x64949a8d.
+//
+// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertGtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertGtDecimal0(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertGtDecimal1 is a free data retrieval call binding the contract method 0x78611f0e.
+//
+// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertGtDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGtDecimal1", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGtDecimal1 is a free data retrieval call binding the contract method 0x78611f0e.
+//
+// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertGtDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertGtDecimal1(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertGtDecimal1 is a free data retrieval call binding the contract method 0x78611f0e.
+//
+// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertGtDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertGtDecimal1(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertGtDecimal2 is a free data retrieval call binding the contract method 0xeccd2437.
+//
+// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertGtDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertGtDecimal2", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGtDecimal2 is a free data retrieval call binding the contract method 0xeccd2437.
+//
+// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertGtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertGtDecimal2(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertGtDecimal2 is a free data retrieval call binding the contract method 0xeccd2437.
+//
+// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertGtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertGtDecimal2(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertLe is a free data retrieval call binding the contract method 0x4dfe692c.
+//
+// Solidity: function assertLe(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmCaller) AssertLe(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLe", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLe is a free data retrieval call binding the contract method 0x4dfe692c.
+//
+// Solidity: function assertLe(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmSession) AssertLe(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertLe(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertLe is a free data retrieval call binding the contract method 0x4dfe692c.
+//
+// Solidity: function assertLe(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertLe(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertLe(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertLe0 is a free data retrieval call binding the contract method 0x8466f415.
+//
+// Solidity: function assertLe(uint256 left, uint256 right) pure returns()
+func (_Vm *VmCaller) AssertLe0(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLe0", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLe0 is a free data retrieval call binding the contract method 0x8466f415.
+//
+// Solidity: function assertLe(uint256 left, uint256 right) pure returns()
+func (_Vm *VmSession) AssertLe0(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertLe0(&_Vm.CallOpts, left, right)
+}
+
+// AssertLe0 is a free data retrieval call binding the contract method 0x8466f415.
+//
+// Solidity: function assertLe(uint256 left, uint256 right) pure returns()
+func (_Vm *VmCallerSession) AssertLe0(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertLe0(&_Vm.CallOpts, left, right)
+}
+
+// AssertLe1 is a free data retrieval call binding the contract method 0x95fd154e.
+//
+// Solidity: function assertLe(int256 left, int256 right) pure returns()
+func (_Vm *VmCaller) AssertLe1(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLe1", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLe1 is a free data retrieval call binding the contract method 0x95fd154e.
+//
+// Solidity: function assertLe(int256 left, int256 right) pure returns()
+func (_Vm *VmSession) AssertLe1(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertLe1(&_Vm.CallOpts, left, right)
+}
+
+// AssertLe1 is a free data retrieval call binding the contract method 0x95fd154e.
+//
+// Solidity: function assertLe(int256 left, int256 right) pure returns()
+func (_Vm *VmCallerSession) AssertLe1(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertLe1(&_Vm.CallOpts, left, right)
+}
+
+// AssertLe2 is a free data retrieval call binding the contract method 0xd17d4b0d.
+//
+// Solidity: function assertLe(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmCaller) AssertLe2(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLe2", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLe2 is a free data retrieval call binding the contract method 0xd17d4b0d.
+//
+// Solidity: function assertLe(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmSession) AssertLe2(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertLe2(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertLe2 is a free data retrieval call binding the contract method 0xd17d4b0d.
+//
+// Solidity: function assertLe(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertLe2(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertLe2(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertLeDecimal is a free data retrieval call binding the contract method 0x11d1364a.
+//
+// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertLeDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLeDecimal", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLeDecimal is a free data retrieval call binding the contract method 0x11d1364a.
+//
+// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertLeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertLeDecimal(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertLeDecimal is a free data retrieval call binding the contract method 0x11d1364a.
+//
+// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertLeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertLeDecimal(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertLeDecimal0 is a free data retrieval call binding the contract method 0x7fefbbe0.
+//
+// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertLeDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLeDecimal0", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLeDecimal0 is a free data retrieval call binding the contract method 0x7fefbbe0.
+//
+// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertLeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertLeDecimal0(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertLeDecimal0 is a free data retrieval call binding the contract method 0x7fefbbe0.
+//
+// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertLeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertLeDecimal0(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertLeDecimal1 is a free data retrieval call binding the contract method 0xaa5cf788.
+//
+// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertLeDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLeDecimal1", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLeDecimal1 is a free data retrieval call binding the contract method 0xaa5cf788.
+//
+// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertLeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertLeDecimal1(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertLeDecimal1 is a free data retrieval call binding the contract method 0xaa5cf788.
+//
+// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertLeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertLeDecimal1(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertLeDecimal2 is a free data retrieval call binding the contract method 0xc304aab7.
+//
+// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertLeDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLeDecimal2", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLeDecimal2 is a free data retrieval call binding the contract method 0xc304aab7.
+//
+// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertLeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertLeDecimal2(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertLeDecimal2 is a free data retrieval call binding the contract method 0xc304aab7.
+//
+// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertLeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertLeDecimal2(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertLt is a free data retrieval call binding the contract method 0x3e914080.
+//
+// Solidity: function assertLt(int256 left, int256 right) pure returns()
+func (_Vm *VmCaller) AssertLt(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLt", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLt is a free data retrieval call binding the contract method 0x3e914080.
+//
+// Solidity: function assertLt(int256 left, int256 right) pure returns()
+func (_Vm *VmSession) AssertLt(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertLt(&_Vm.CallOpts, left, right)
+}
+
+// AssertLt is a free data retrieval call binding the contract method 0x3e914080.
+//
+// Solidity: function assertLt(int256 left, int256 right) pure returns()
+func (_Vm *VmCallerSession) AssertLt(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertLt(&_Vm.CallOpts, left, right)
+}
+
+// AssertLt0 is a free data retrieval call binding the contract method 0x65d5c135.
+//
+// Solidity: function assertLt(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmCaller) AssertLt0(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLt0", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLt0 is a free data retrieval call binding the contract method 0x65d5c135.
+//
+// Solidity: function assertLt(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmSession) AssertLt0(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertLt0(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertLt0 is a free data retrieval call binding the contract method 0x65d5c135.
+//
+// Solidity: function assertLt(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertLt0(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertLt0(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertLt1 is a free data retrieval call binding the contract method 0x9ff531e3.
+//
+// Solidity: function assertLt(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmCaller) AssertLt1(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLt1", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLt1 is a free data retrieval call binding the contract method 0x9ff531e3.
+//
+// Solidity: function assertLt(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmSession) AssertLt1(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertLt1(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertLt1 is a free data retrieval call binding the contract method 0x9ff531e3.
+//
+// Solidity: function assertLt(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertLt1(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertLt1(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertLt2 is a free data retrieval call binding the contract method 0xb12fc005.
+//
+// Solidity: function assertLt(uint256 left, uint256 right) pure returns()
+func (_Vm *VmCaller) AssertLt2(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLt2", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLt2 is a free data retrieval call binding the contract method 0xb12fc005.
+//
+// Solidity: function assertLt(uint256 left, uint256 right) pure returns()
+func (_Vm *VmSession) AssertLt2(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertLt2(&_Vm.CallOpts, left, right)
+}
+
+// AssertLt2 is a free data retrieval call binding the contract method 0xb12fc005.
+//
+// Solidity: function assertLt(uint256 left, uint256 right) pure returns()
+func (_Vm *VmCallerSession) AssertLt2(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertLt2(&_Vm.CallOpts, left, right)
+}
+
+// AssertLtDecimal is a free data retrieval call binding the contract method 0x2077337e.
+//
+// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertLtDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLtDecimal", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLtDecimal is a free data retrieval call binding the contract method 0x2077337e.
+//
+// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertLtDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertLtDecimal(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertLtDecimal is a free data retrieval call binding the contract method 0x2077337e.
+//
+// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertLtDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertLtDecimal(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertLtDecimal0 is a free data retrieval call binding the contract method 0x40f0b4e0.
+//
+// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertLtDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLtDecimal0", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLtDecimal0 is a free data retrieval call binding the contract method 0x40f0b4e0.
+//
+// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertLtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertLtDecimal0(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertLtDecimal0 is a free data retrieval call binding the contract method 0x40f0b4e0.
+//
+// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertLtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertLtDecimal0(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertLtDecimal1 is a free data retrieval call binding the contract method 0xa972d037.
+//
+// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertLtDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLtDecimal1", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLtDecimal1 is a free data retrieval call binding the contract method 0xa972d037.
+//
+// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertLtDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertLtDecimal1(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertLtDecimal1 is a free data retrieval call binding the contract method 0xa972d037.
+//
+// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertLtDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertLtDecimal1(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertLtDecimal2 is a free data retrieval call binding the contract method 0xdbe8d88b.
+//
+// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertLtDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertLtDecimal2", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLtDecimal2 is a free data retrieval call binding the contract method 0xdbe8d88b.
+//
+// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertLtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertLtDecimal2(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertLtDecimal2 is a free data retrieval call binding the contract method 0xdbe8d88b.
+//
+// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertLtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertLtDecimal2(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertNotEq is a free data retrieval call binding the contract method 0x0603ea68.
+//
+// Solidity: function assertNotEq(bytes32[] left, bytes32[] right) pure returns()
+func (_Vm *VmCaller) AssertNotEq(opts *bind.CallOpts, left [][32]byte, right [][32]byte) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq is a free data retrieval call binding the contract method 0x0603ea68.
+//
+// Solidity: function assertNotEq(bytes32[] left, bytes32[] right) pure returns()
+func (_Vm *VmSession) AssertNotEq(left [][32]byte, right [][32]byte) error {
+	return _Vm.Contract.AssertNotEq(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq is a free data retrieval call binding the contract method 0x0603ea68.
+//
+// Solidity: function assertNotEq(bytes32[] left, bytes32[] right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq(left [][32]byte, right [][32]byte) error {
+	return _Vm.Contract.AssertNotEq(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq0 is a free data retrieval call binding the contract method 0x0b72f4ef.
+//
+// Solidity: function assertNotEq(int256[] left, int256[] right) pure returns()
+func (_Vm *VmCaller) AssertNotEq0(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq0", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq0 is a free data retrieval call binding the contract method 0x0b72f4ef.
+//
+// Solidity: function assertNotEq(int256[] left, int256[] right) pure returns()
+func (_Vm *VmSession) AssertNotEq0(left []*big.Int, right []*big.Int) error {
+	return _Vm.Contract.AssertNotEq0(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq0 is a free data retrieval call binding the contract method 0x0b72f4ef.
+//
+// Solidity: function assertNotEq(int256[] left, int256[] right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq0(left []*big.Int, right []*big.Int) error {
+	return _Vm.Contract.AssertNotEq0(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq1 is a free data retrieval call binding the contract method 0x1091a261.
+//
+// Solidity: function assertNotEq(bool left, bool right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq1(opts *bind.CallOpts, left bool, right bool, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq1", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq1 is a free data retrieval call binding the contract method 0x1091a261.
+//
+// Solidity: function assertNotEq(bool left, bool right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq1(left bool, right bool, error string) error {
+	return _Vm.Contract.AssertNotEq1(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq1 is a free data retrieval call binding the contract method 0x1091a261.
+//
+// Solidity: function assertNotEq(bool left, bool right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq1(left bool, right bool, error string) error {
+	return _Vm.Contract.AssertNotEq1(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq10 is a free data retrieval call binding the contract method 0x6a8237b3.
+//
+// Solidity: function assertNotEq(string left, string right) pure returns()
+func (_Vm *VmCaller) AssertNotEq10(opts *bind.CallOpts, left string, right string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq10", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq10 is a free data retrieval call binding the contract method 0x6a8237b3.
+//
+// Solidity: function assertNotEq(string left, string right) pure returns()
+func (_Vm *VmSession) AssertNotEq10(left string, right string) error {
+	return _Vm.Contract.AssertNotEq10(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq10 is a free data retrieval call binding the contract method 0x6a8237b3.
+//
+// Solidity: function assertNotEq(string left, string right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq10(left string, right string) error {
+	return _Vm.Contract.AssertNotEq10(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq11 is a free data retrieval call binding the contract method 0x72c7e0b5.
+//
+// Solidity: function assertNotEq(address[] left, address[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq11(opts *bind.CallOpts, left []common.Address, right []common.Address, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq11", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq11 is a free data retrieval call binding the contract method 0x72c7e0b5.
+//
+// Solidity: function assertNotEq(address[] left, address[] right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq11(left []common.Address, right []common.Address, error string) error {
+	return _Vm.Contract.AssertNotEq11(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq11 is a free data retrieval call binding the contract method 0x72c7e0b5.
+//
+// Solidity: function assertNotEq(address[] left, address[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq11(left []common.Address, right []common.Address, error string) error {
+	return _Vm.Contract.AssertNotEq11(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq12 is a free data retrieval call binding the contract method 0x78bdcea7.
+//
+// Solidity: function assertNotEq(string left, string right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq12(opts *bind.CallOpts, left string, right string, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq12", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq12 is a free data retrieval call binding the contract method 0x78bdcea7.
+//
+// Solidity: function assertNotEq(string left, string right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq12(left string, right string, error string) error {
+	return _Vm.Contract.AssertNotEq12(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq12 is a free data retrieval call binding the contract method 0x78bdcea7.
+//
+// Solidity: function assertNotEq(string left, string right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq12(left string, right string, error string) error {
+	return _Vm.Contract.AssertNotEq12(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq13 is a free data retrieval call binding the contract method 0x8775a591.
+//
+// Solidity: function assertNotEq(address left, address right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq13(opts *bind.CallOpts, left common.Address, right common.Address, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq13", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq13 is a free data retrieval call binding the contract method 0x8775a591.
+//
+// Solidity: function assertNotEq(address left, address right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq13(left common.Address, right common.Address, error string) error {
+	return _Vm.Contract.AssertNotEq13(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq13 is a free data retrieval call binding the contract method 0x8775a591.
+//
+// Solidity: function assertNotEq(address left, address right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq13(left common.Address, right common.Address, error string) error {
+	return _Vm.Contract.AssertNotEq13(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq14 is a free data retrieval call binding the contract method 0x898e83fc.
+//
+// Solidity: function assertNotEq(bytes32 left, bytes32 right) pure returns()
+func (_Vm *VmCaller) AssertNotEq14(opts *bind.CallOpts, left [32]byte, right [32]byte) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq14", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq14 is a free data retrieval call binding the contract method 0x898e83fc.
+//
+// Solidity: function assertNotEq(bytes32 left, bytes32 right) pure returns()
+func (_Vm *VmSession) AssertNotEq14(left [32]byte, right [32]byte) error {
+	return _Vm.Contract.AssertNotEq14(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq14 is a free data retrieval call binding the contract method 0x898e83fc.
+//
+// Solidity: function assertNotEq(bytes32 left, bytes32 right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq14(left [32]byte, right [32]byte) error {
+	return _Vm.Contract.AssertNotEq14(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq15 is a free data retrieval call binding the contract method 0x9507540e.
+//
+// Solidity: function assertNotEq(bytes left, bytes right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq15(opts *bind.CallOpts, left []byte, right []byte, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq15", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq15 is a free data retrieval call binding the contract method 0x9507540e.
+//
+// Solidity: function assertNotEq(bytes left, bytes right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq15(left []byte, right []byte, error string) error {
+	return _Vm.Contract.AssertNotEq15(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq15 is a free data retrieval call binding the contract method 0x9507540e.
+//
+// Solidity: function assertNotEq(bytes left, bytes right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq15(left []byte, right []byte, error string) error {
+	return _Vm.Contract.AssertNotEq15(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq16 is a free data retrieval call binding the contract method 0x98f9bdbd.
+//
+// Solidity: function assertNotEq(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq16(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq16", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq16 is a free data retrieval call binding the contract method 0x98f9bdbd.
+//
+// Solidity: function assertNotEq(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq16(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertNotEq16(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq16 is a free data retrieval call binding the contract method 0x98f9bdbd.
+//
+// Solidity: function assertNotEq(uint256 left, uint256 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq16(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertNotEq16(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq17 is a free data retrieval call binding the contract method 0x9a7fbd8f.
+//
+// Solidity: function assertNotEq(uint256[] left, uint256[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq17(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq17", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq17 is a free data retrieval call binding the contract method 0x9a7fbd8f.
+//
+// Solidity: function assertNotEq(uint256[] left, uint256[] right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq17(left []*big.Int, right []*big.Int, error string) error {
+	return _Vm.Contract.AssertNotEq17(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq17 is a free data retrieval call binding the contract method 0x9a7fbd8f.
+//
+// Solidity: function assertNotEq(uint256[] left, uint256[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq17(left []*big.Int, right []*big.Int, error string) error {
+	return _Vm.Contract.AssertNotEq17(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq18 is a free data retrieval call binding the contract method 0xb12e1694.
+//
+// Solidity: function assertNotEq(address left, address right) pure returns()
+func (_Vm *VmCaller) AssertNotEq18(opts *bind.CallOpts, left common.Address, right common.Address) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq18", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq18 is a free data retrieval call binding the contract method 0xb12e1694.
+//
+// Solidity: function assertNotEq(address left, address right) pure returns()
+func (_Vm *VmSession) AssertNotEq18(left common.Address, right common.Address) error {
+	return _Vm.Contract.AssertNotEq18(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq18 is a free data retrieval call binding the contract method 0xb12e1694.
+//
+// Solidity: function assertNotEq(address left, address right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq18(left common.Address, right common.Address) error {
+	return _Vm.Contract.AssertNotEq18(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq19 is a free data retrieval call binding the contract method 0xb2332f51.
+//
+// Solidity: function assertNotEq(bytes32 left, bytes32 right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq19(opts *bind.CallOpts, left [32]byte, right [32]byte, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq19", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq19 is a free data retrieval call binding the contract method 0xb2332f51.
+//
+// Solidity: function assertNotEq(bytes32 left, bytes32 right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq19(left [32]byte, right [32]byte, error string) error {
+	return _Vm.Contract.AssertNotEq19(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq19 is a free data retrieval call binding the contract method 0xb2332f51.
+//
+// Solidity: function assertNotEq(bytes32 left, bytes32 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq19(left [32]byte, right [32]byte, error string) error {
+	return _Vm.Contract.AssertNotEq19(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq2 is a free data retrieval call binding the contract method 0x1dcd1f68.
+//
+// Solidity: function assertNotEq(bytes[] left, bytes[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq2(opts *bind.CallOpts, left [][]byte, right [][]byte, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq2", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq2 is a free data retrieval call binding the contract method 0x1dcd1f68.
+//
+// Solidity: function assertNotEq(bytes[] left, bytes[] right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq2(left [][]byte, right [][]byte, error string) error {
+	return _Vm.Contract.AssertNotEq2(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq2 is a free data retrieval call binding the contract method 0x1dcd1f68.
+//
+// Solidity: function assertNotEq(bytes[] left, bytes[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq2(left [][]byte, right [][]byte, error string) error {
+	return _Vm.Contract.AssertNotEq2(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq20 is a free data retrieval call binding the contract method 0xb67187f3.
+//
+// Solidity: function assertNotEq(string[] left, string[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq20(opts *bind.CallOpts, left []string, right []string, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq20", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq20 is a free data retrieval call binding the contract method 0xb67187f3.
+//
+// Solidity: function assertNotEq(string[] left, string[] right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq20(left []string, right []string, error string) error {
+	return _Vm.Contract.AssertNotEq20(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq20 is a free data retrieval call binding the contract method 0xb67187f3.
+//
+// Solidity: function assertNotEq(string[] left, string[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq20(left []string, right []string, error string) error {
+	return _Vm.Contract.AssertNotEq20(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq21 is a free data retrieval call binding the contract method 0xb7909320.
+//
+// Solidity: function assertNotEq(uint256 left, uint256 right) pure returns()
+func (_Vm *VmCaller) AssertNotEq21(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq21", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq21 is a free data retrieval call binding the contract method 0xb7909320.
+//
+// Solidity: function assertNotEq(uint256 left, uint256 right) pure returns()
+func (_Vm *VmSession) AssertNotEq21(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertNotEq21(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq21 is a free data retrieval call binding the contract method 0xb7909320.
+//
+// Solidity: function assertNotEq(uint256 left, uint256 right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq21(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertNotEq21(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq22 is a free data retrieval call binding the contract method 0xb873634c.
+//
+// Solidity: function assertNotEq(bytes32[] left, bytes32[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq22(opts *bind.CallOpts, left [][32]byte, right [][32]byte, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq22", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq22 is a free data retrieval call binding the contract method 0xb873634c.
+//
+// Solidity: function assertNotEq(bytes32[] left, bytes32[] right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq22(left [][32]byte, right [][32]byte, error string) error {
+	return _Vm.Contract.AssertNotEq22(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq22 is a free data retrieval call binding the contract method 0xb873634c.
+//
+// Solidity: function assertNotEq(bytes32[] left, bytes32[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq22(left [][32]byte, right [][32]byte, error string) error {
+	return _Vm.Contract.AssertNotEq22(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq23 is a free data retrieval call binding the contract method 0xbdfacbe8.
+//
+// Solidity: function assertNotEq(string[] left, string[] right) pure returns()
+func (_Vm *VmCaller) AssertNotEq23(opts *bind.CallOpts, left []string, right []string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq23", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq23 is a free data retrieval call binding the contract method 0xbdfacbe8.
+//
+// Solidity: function assertNotEq(string[] left, string[] right) pure returns()
+func (_Vm *VmSession) AssertNotEq23(left []string, right []string) error {
+	return _Vm.Contract.AssertNotEq23(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq23 is a free data retrieval call binding the contract method 0xbdfacbe8.
+//
+// Solidity: function assertNotEq(string[] left, string[] right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq23(left []string, right []string) error {
+	return _Vm.Contract.AssertNotEq23(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq24 is a free data retrieval call binding the contract method 0xd3977322.
+//
+// Solidity: function assertNotEq(int256[] left, int256[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq24(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq24", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq24 is a free data retrieval call binding the contract method 0xd3977322.
+//
+// Solidity: function assertNotEq(int256[] left, int256[] right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq24(left []*big.Int, right []*big.Int, error string) error {
+	return _Vm.Contract.AssertNotEq24(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq24 is a free data retrieval call binding the contract method 0xd3977322.
+//
+// Solidity: function assertNotEq(int256[] left, int256[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq24(left []*big.Int, right []*big.Int, error string) error {
+	return _Vm.Contract.AssertNotEq24(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq25 is a free data retrieval call binding the contract method 0xedecd035.
+//
+// Solidity: function assertNotEq(bytes[] left, bytes[] right) pure returns()
+func (_Vm *VmCaller) AssertNotEq25(opts *bind.CallOpts, left [][]byte, right [][]byte) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq25", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq25 is a free data retrieval call binding the contract method 0xedecd035.
+//
+// Solidity: function assertNotEq(bytes[] left, bytes[] right) pure returns()
+func (_Vm *VmSession) AssertNotEq25(left [][]byte, right [][]byte) error {
+	return _Vm.Contract.AssertNotEq25(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq25 is a free data retrieval call binding the contract method 0xedecd035.
+//
+// Solidity: function assertNotEq(bytes[] left, bytes[] right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq25(left [][]byte, right [][]byte) error {
+	return _Vm.Contract.AssertNotEq25(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq26 is a free data retrieval call binding the contract method 0xf4c004e3.
+//
+// Solidity: function assertNotEq(int256 left, int256 right) pure returns()
+func (_Vm *VmCaller) AssertNotEq26(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq26", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq26 is a free data retrieval call binding the contract method 0xf4c004e3.
+//
+// Solidity: function assertNotEq(int256 left, int256 right) pure returns()
+func (_Vm *VmSession) AssertNotEq26(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertNotEq26(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq26 is a free data retrieval call binding the contract method 0xf4c004e3.
+//
+// Solidity: function assertNotEq(int256 left, int256 right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq26(left *big.Int, right *big.Int) error {
+	return _Vm.Contract.AssertNotEq26(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq3 is a free data retrieval call binding the contract method 0x236e4d66.
+//
+// Solidity: function assertNotEq(bool left, bool right) pure returns()
+func (_Vm *VmCaller) AssertNotEq3(opts *bind.CallOpts, left bool, right bool) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq3", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq3 is a free data retrieval call binding the contract method 0x236e4d66.
+//
+// Solidity: function assertNotEq(bool left, bool right) pure returns()
+func (_Vm *VmSession) AssertNotEq3(left bool, right bool) error {
+	return _Vm.Contract.AssertNotEq3(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq3 is a free data retrieval call binding the contract method 0x236e4d66.
+//
+// Solidity: function assertNotEq(bool left, bool right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq3(left bool, right bool) error {
+	return _Vm.Contract.AssertNotEq3(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq4 is a free data retrieval call binding the contract method 0x286fafea.
+//
+// Solidity: function assertNotEq(bool[] left, bool[] right) pure returns()
+func (_Vm *VmCaller) AssertNotEq4(opts *bind.CallOpts, left []bool, right []bool) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq4", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq4 is a free data retrieval call binding the contract method 0x286fafea.
+//
+// Solidity: function assertNotEq(bool[] left, bool[] right) pure returns()
+func (_Vm *VmSession) AssertNotEq4(left []bool, right []bool) error {
+	return _Vm.Contract.AssertNotEq4(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq4 is a free data retrieval call binding the contract method 0x286fafea.
+//
+// Solidity: function assertNotEq(bool[] left, bool[] right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq4(left []bool, right []bool) error {
+	return _Vm.Contract.AssertNotEq4(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq5 is a free data retrieval call binding the contract method 0x3cf78e28.
+//
+// Solidity: function assertNotEq(bytes left, bytes right) pure returns()
+func (_Vm *VmCaller) AssertNotEq5(opts *bind.CallOpts, left []byte, right []byte) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq5", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq5 is a free data retrieval call binding the contract method 0x3cf78e28.
+//
+// Solidity: function assertNotEq(bytes left, bytes right) pure returns()
+func (_Vm *VmSession) AssertNotEq5(left []byte, right []byte) error {
+	return _Vm.Contract.AssertNotEq5(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq5 is a free data retrieval call binding the contract method 0x3cf78e28.
+//
+// Solidity: function assertNotEq(bytes left, bytes right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq5(left []byte, right []byte) error {
+	return _Vm.Contract.AssertNotEq5(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq6 is a free data retrieval call binding the contract method 0x46d0b252.
+//
+// Solidity: function assertNotEq(address[] left, address[] right) pure returns()
+func (_Vm *VmCaller) AssertNotEq6(opts *bind.CallOpts, left []common.Address, right []common.Address) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq6", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq6 is a free data retrieval call binding the contract method 0x46d0b252.
+//
+// Solidity: function assertNotEq(address[] left, address[] right) pure returns()
+func (_Vm *VmSession) AssertNotEq6(left []common.Address, right []common.Address) error {
+	return _Vm.Contract.AssertNotEq6(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq6 is a free data retrieval call binding the contract method 0x46d0b252.
+//
+// Solidity: function assertNotEq(address[] left, address[] right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq6(left []common.Address, right []common.Address) error {
+	return _Vm.Contract.AssertNotEq6(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq7 is a free data retrieval call binding the contract method 0x4724c5b9.
+//
+// Solidity: function assertNotEq(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq7(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq7", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq7 is a free data retrieval call binding the contract method 0x4724c5b9.
+//
+// Solidity: function assertNotEq(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq7(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertNotEq7(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq7 is a free data retrieval call binding the contract method 0x4724c5b9.
+//
+// Solidity: function assertNotEq(int256 left, int256 right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq7(left *big.Int, right *big.Int, error string) error {
+	return _Vm.Contract.AssertNotEq7(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq8 is a free data retrieval call binding the contract method 0x56f29cba.
+//
+// Solidity: function assertNotEq(uint256[] left, uint256[] right) pure returns()
+func (_Vm *VmCaller) AssertNotEq8(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq8", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq8 is a free data retrieval call binding the contract method 0x56f29cba.
+//
+// Solidity: function assertNotEq(uint256[] left, uint256[] right) pure returns()
+func (_Vm *VmSession) AssertNotEq8(left []*big.Int, right []*big.Int) error {
+	return _Vm.Contract.AssertNotEq8(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq8 is a free data retrieval call binding the contract method 0x56f29cba.
+//
+// Solidity: function assertNotEq(uint256[] left, uint256[] right) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq8(left []*big.Int, right []*big.Int) error {
+	return _Vm.Contract.AssertNotEq8(&_Vm.CallOpts, left, right)
+}
+
+// AssertNotEq9 is a free data retrieval call binding the contract method 0x62c6f9fb.
+//
+// Solidity: function assertNotEq(bool[] left, bool[] right, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEq9(opts *bind.CallOpts, left []bool, right []bool, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEq9", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq9 is a free data retrieval call binding the contract method 0x62c6f9fb.
+//
+// Solidity: function assertNotEq(bool[] left, bool[] right, string error) pure returns()
+func (_Vm *VmSession) AssertNotEq9(left []bool, right []bool, error string) error {
+	return _Vm.Contract.AssertNotEq9(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEq9 is a free data retrieval call binding the contract method 0x62c6f9fb.
+//
+// Solidity: function assertNotEq(bool[] left, bool[] right, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEq9(left []bool, right []bool, error string) error {
+	return _Vm.Contract.AssertNotEq9(&_Vm.CallOpts, left, right, error)
+}
+
+// AssertNotEqDecimal is a free data retrieval call binding the contract method 0x14e75680.
+//
+// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertNotEqDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEqDecimal", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEqDecimal is a free data retrieval call binding the contract method 0x14e75680.
+//
+// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertNotEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertNotEqDecimal(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertNotEqDecimal is a free data retrieval call binding the contract method 0x14e75680.
+//
+// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertNotEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertNotEqDecimal(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertNotEqDecimal0 is a free data retrieval call binding the contract method 0x33949f0b.
+//
+// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEqDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEqDecimal0", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEqDecimal0 is a free data retrieval call binding the contract method 0x33949f0b.
+//
+// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertNotEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertNotEqDecimal0(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertNotEqDecimal0 is a free data retrieval call binding the contract method 0x33949f0b.
+//
+// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertNotEqDecimal0(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertNotEqDecimal1 is a free data retrieval call binding the contract method 0x669efca7.
+//
+// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmCaller) AssertNotEqDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEqDecimal1", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEqDecimal1 is a free data retrieval call binding the contract method 0x669efca7.
+//
+// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmSession) AssertNotEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertNotEqDecimal1(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertNotEqDecimal1 is a free data retrieval call binding the contract method 0x669efca7.
+//
+// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_Vm *VmCallerSession) AssertNotEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _Vm.Contract.AssertNotEqDecimal1(&_Vm.CallOpts, left, right, decimals)
+}
+
+// AssertNotEqDecimal2 is a free data retrieval call binding the contract method 0xf5a55558.
+//
+// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCaller) AssertNotEqDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertNotEqDecimal2", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEqDecimal2 is a free data retrieval call binding the contract method 0xf5a55558.
+//
+// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmSession) AssertNotEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertNotEqDecimal2(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertNotEqDecimal2 is a free data retrieval call binding the contract method 0xf5a55558.
+//
+// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_Vm *VmCallerSession) AssertNotEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _Vm.Contract.AssertNotEqDecimal2(&_Vm.CallOpts, left, right, decimals, error)
+}
+
+// AssertTrue is a free data retrieval call binding the contract method 0x0c9fd581.
+//
+// Solidity: function assertTrue(bool condition) pure returns()
+func (_Vm *VmCaller) AssertTrue(opts *bind.CallOpts, condition bool) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertTrue", condition)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertTrue is a free data retrieval call binding the contract method 0x0c9fd581.
+//
+// Solidity: function assertTrue(bool condition) pure returns()
+func (_Vm *VmSession) AssertTrue(condition bool) error {
+	return _Vm.Contract.AssertTrue(&_Vm.CallOpts, condition)
+}
+
+// AssertTrue is a free data retrieval call binding the contract method 0x0c9fd581.
+//
+// Solidity: function assertTrue(bool condition) pure returns()
+func (_Vm *VmCallerSession) AssertTrue(condition bool) error {
+	return _Vm.Contract.AssertTrue(&_Vm.CallOpts, condition)
+}
+
+// AssertTrue0 is a free data retrieval call binding the contract method 0xa34edc03.
+//
+// Solidity: function assertTrue(bool condition, string error) pure returns()
+func (_Vm *VmCaller) AssertTrue0(opts *bind.CallOpts, condition bool, error string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assertTrue0", condition, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertTrue0 is a free data retrieval call binding the contract method 0xa34edc03.
+//
+// Solidity: function assertTrue(bool condition, string error) pure returns()
+func (_Vm *VmSession) AssertTrue0(condition bool, error string) error {
+	return _Vm.Contract.AssertTrue0(&_Vm.CallOpts, condition, error)
+}
+
+// AssertTrue0 is a free data retrieval call binding the contract method 0xa34edc03.
+//
+// Solidity: function assertTrue(bool condition, string error) pure returns()
+func (_Vm *VmCallerSession) AssertTrue0(condition bool, error string) error {
+	return _Vm.Contract.AssertTrue0(&_Vm.CallOpts, condition, error)
+}
+
+// Assume is a free data retrieval call binding the contract method 0x4c63e562.
+//
+// Solidity: function assume(bool condition) pure returns()
+func (_Vm *VmCaller) Assume(opts *bind.CallOpts, condition bool) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assume", condition)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// Assume is a free data retrieval call binding the contract method 0x4c63e562.
+//
+// Solidity: function assume(bool condition) pure returns()
+func (_Vm *VmSession) Assume(condition bool) error {
+	return _Vm.Contract.Assume(&_Vm.CallOpts, condition)
+}
+
+// Assume is a free data retrieval call binding the contract method 0x4c63e562.
+//
+// Solidity: function assume(bool condition) pure returns()
+func (_Vm *VmCallerSession) Assume(condition bool) error {
+	return _Vm.Contract.Assume(&_Vm.CallOpts, condition)
+}
+
+// AssumeNoRevert is a free data retrieval call binding the contract method 0x285b366a.
+//
+// Solidity: function assumeNoRevert() pure returns()
+func (_Vm *VmCaller) AssumeNoRevert(opts *bind.CallOpts) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assumeNoRevert")
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssumeNoRevert is a free data retrieval call binding the contract method 0x285b366a.
+//
+// Solidity: function assumeNoRevert() pure returns()
+func (_Vm *VmSession) AssumeNoRevert() error {
+	return _Vm.Contract.AssumeNoRevert(&_Vm.CallOpts)
+}
+
+// AssumeNoRevert is a free data retrieval call binding the contract method 0x285b366a.
+//
+// Solidity: function assumeNoRevert() pure returns()
+func (_Vm *VmCallerSession) AssumeNoRevert() error {
+	return _Vm.Contract.AssumeNoRevert(&_Vm.CallOpts)
+}
+
+// AssumeNoRevert0 is a free data retrieval call binding the contract method 0x8a4592cc.
+//
+// Solidity: function assumeNoRevert((address,bool,bytes)[] potentialReverts) pure returns()
+func (_Vm *VmCaller) AssumeNoRevert0(opts *bind.CallOpts, potentialReverts []VmSafePotentialRevert) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assumeNoRevert0", potentialReverts)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssumeNoRevert0 is a free data retrieval call binding the contract method 0x8a4592cc.
+//
+// Solidity: function assumeNoRevert((address,bool,bytes)[] potentialReverts) pure returns()
+func (_Vm *VmSession) AssumeNoRevert0(potentialReverts []VmSafePotentialRevert) error {
+	return _Vm.Contract.AssumeNoRevert0(&_Vm.CallOpts, potentialReverts)
+}
+
+// AssumeNoRevert0 is a free data retrieval call binding the contract method 0x8a4592cc.
+//
+// Solidity: function assumeNoRevert((address,bool,bytes)[] potentialReverts) pure returns()
+func (_Vm *VmCallerSession) AssumeNoRevert0(potentialReverts []VmSafePotentialRevert) error {
+	return _Vm.Contract.AssumeNoRevert0(&_Vm.CallOpts, potentialReverts)
+}
+
+// AssumeNoRevert1 is a free data retrieval call binding the contract method 0xd8591eeb.
+//
+// Solidity: function assumeNoRevert((address,bool,bytes) potentialRevert) pure returns()
+func (_Vm *VmCaller) AssumeNoRevert1(opts *bind.CallOpts, potentialRevert VmSafePotentialRevert) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "assumeNoRevert1", potentialRevert)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssumeNoRevert1 is a free data retrieval call binding the contract method 0xd8591eeb.
+//
+// Solidity: function assumeNoRevert((address,bool,bytes) potentialRevert) pure returns()
+func (_Vm *VmSession) AssumeNoRevert1(potentialRevert VmSafePotentialRevert) error {
+	return _Vm.Contract.AssumeNoRevert1(&_Vm.CallOpts, potentialRevert)
+}
+
+// AssumeNoRevert1 is a free data retrieval call binding the contract method 0xd8591eeb.
+//
+// Solidity: function assumeNoRevert((address,bool,bytes) potentialRevert) pure returns()
+func (_Vm *VmCallerSession) AssumeNoRevert1(potentialRevert VmSafePotentialRevert) error {
+	return _Vm.Contract.AssumeNoRevert1(&_Vm.CallOpts, potentialRevert)
+}
+
+// Breakpoint is a free data retrieval call binding the contract method 0xf0259e92.
+//
+// Solidity: function breakpoint(string char) pure returns()
+func (_Vm *VmCaller) Breakpoint(opts *bind.CallOpts, char string) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "breakpoint", char)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// Breakpoint is a free data retrieval call binding the contract method 0xf0259e92.
+//
+// Solidity: function breakpoint(string char) pure returns()
+func (_Vm *VmSession) Breakpoint(char string) error {
+	return _Vm.Contract.Breakpoint(&_Vm.CallOpts, char)
+}
+
+// Breakpoint is a free data retrieval call binding the contract method 0xf0259e92.
+//
+// Solidity: function breakpoint(string char) pure returns()
+func (_Vm *VmCallerSession) Breakpoint(char string) error {
+	return _Vm.Contract.Breakpoint(&_Vm.CallOpts, char)
+}
+
+// Breakpoint0 is a free data retrieval call binding the contract method 0xf7d39a8d.
+//
+// Solidity: function breakpoint(string char, bool value) pure returns()
+func (_Vm *VmCaller) Breakpoint0(opts *bind.CallOpts, char string, value bool) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "breakpoint0", char, value)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// Breakpoint0 is a free data retrieval call binding the contract method 0xf7d39a8d.
+//
+// Solidity: function breakpoint(string char, bool value) pure returns()
+func (_Vm *VmSession) Breakpoint0(char string, value bool) error {
+	return _Vm.Contract.Breakpoint0(&_Vm.CallOpts, char, value)
+}
+
+// Breakpoint0 is a free data retrieval call binding the contract method 0xf7d39a8d.
+//
+// Solidity: function breakpoint(string char, bool value) pure returns()
+func (_Vm *VmCallerSession) Breakpoint0(char string, value bool) error {
+	return _Vm.Contract.Breakpoint0(&_Vm.CallOpts, char, value)
+}
+
+// ComputeCreate2Address is a free data retrieval call binding the contract method 0x890c283b.
+//
+// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) pure returns(address)
+func (_Vm *VmCaller) ComputeCreate2Address(opts *bind.CallOpts, salt [32]byte, initCodeHash [32]byte) (common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "computeCreate2Address", salt, initCodeHash)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// ComputeCreate2Address is a free data retrieval call binding the contract method 0x890c283b.
+//
+// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) pure returns(address)
+func (_Vm *VmSession) ComputeCreate2Address(salt [32]byte, initCodeHash [32]byte) (common.Address, error) {
+	return _Vm.Contract.ComputeCreate2Address(&_Vm.CallOpts, salt, initCodeHash)
+}
+
+// ComputeCreate2Address is a free data retrieval call binding the contract method 0x890c283b.
+//
+// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) pure returns(address)
+func (_Vm *VmCallerSession) ComputeCreate2Address(salt [32]byte, initCodeHash [32]byte) (common.Address, error) {
+	return _Vm.Contract.ComputeCreate2Address(&_Vm.CallOpts, salt, initCodeHash)
+}
+
+// ComputeCreate2Address0 is a free data retrieval call binding the contract method 0xd323826a.
+//
+// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) pure returns(address)
+func (_Vm *VmCaller) ComputeCreate2Address0(opts *bind.CallOpts, salt [32]byte, initCodeHash [32]byte, deployer common.Address) (common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "computeCreate2Address0", salt, initCodeHash, deployer)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// ComputeCreate2Address0 is a free data retrieval call binding the contract method 0xd323826a.
+//
+// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) pure returns(address)
+func (_Vm *VmSession) ComputeCreate2Address0(salt [32]byte, initCodeHash [32]byte, deployer common.Address) (common.Address, error) {
+	return _Vm.Contract.ComputeCreate2Address0(&_Vm.CallOpts, salt, initCodeHash, deployer)
+}
+
+// ComputeCreate2Address0 is a free data retrieval call binding the contract method 0xd323826a.
+//
+// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) pure returns(address)
+func (_Vm *VmCallerSession) ComputeCreate2Address0(salt [32]byte, initCodeHash [32]byte, deployer common.Address) (common.Address, error) {
+	return _Vm.Contract.ComputeCreate2Address0(&_Vm.CallOpts, salt, initCodeHash, deployer)
+}
+
+// ComputeCreateAddress is a free data retrieval call binding the contract method 0x74637a7a.
+//
+// Solidity: function computeCreateAddress(address deployer, uint256 nonce) pure returns(address)
+func (_Vm *VmCaller) ComputeCreateAddress(opts *bind.CallOpts, deployer common.Address, nonce *big.Int) (common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "computeCreateAddress", deployer, nonce)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// ComputeCreateAddress is a free data retrieval call binding the contract method 0x74637a7a.
+//
+// Solidity: function computeCreateAddress(address deployer, uint256 nonce) pure returns(address)
+func (_Vm *VmSession) ComputeCreateAddress(deployer common.Address, nonce *big.Int) (common.Address, error) {
+	return _Vm.Contract.ComputeCreateAddress(&_Vm.CallOpts, deployer, nonce)
+}
+
+// ComputeCreateAddress is a free data retrieval call binding the contract method 0x74637a7a.
+//
+// Solidity: function computeCreateAddress(address deployer, uint256 nonce) pure returns(address)
+func (_Vm *VmCallerSession) ComputeCreateAddress(deployer common.Address, nonce *big.Int) (common.Address, error) {
+	return _Vm.Contract.ComputeCreateAddress(&_Vm.CallOpts, deployer, nonce)
+}
+
+// DeriveKey is a free data retrieval call binding the contract method 0x29233b1f.
+//
+// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index, string language) pure returns(uint256 privateKey)
+func (_Vm *VmCaller) DeriveKey(opts *bind.CallOpts, mnemonic string, derivationPath string, index uint32, language string) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "deriveKey", mnemonic, derivationPath, index, language)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// DeriveKey is a free data retrieval call binding the contract method 0x29233b1f.
+//
+// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index, string language) pure returns(uint256 privateKey)
+func (_Vm *VmSession) DeriveKey(mnemonic string, derivationPath string, index uint32, language string) (*big.Int, error) {
+	return _Vm.Contract.DeriveKey(&_Vm.CallOpts, mnemonic, derivationPath, index, language)
+}
+
+// DeriveKey is a free data retrieval call binding the contract method 0x29233b1f.
+//
+// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index, string language) pure returns(uint256 privateKey)
+func (_Vm *VmCallerSession) DeriveKey(mnemonic string, derivationPath string, index uint32, language string) (*big.Int, error) {
+	return _Vm.Contract.DeriveKey(&_Vm.CallOpts, mnemonic, derivationPath, index, language)
+}
+
+// DeriveKey0 is a free data retrieval call binding the contract method 0x32c8176d.
+//
+// Solidity: function deriveKey(string mnemonic, uint32 index, string language) pure returns(uint256 privateKey)
+func (_Vm *VmCaller) DeriveKey0(opts *bind.CallOpts, mnemonic string, index uint32, language string) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "deriveKey0", mnemonic, index, language)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// DeriveKey0 is a free data retrieval call binding the contract method 0x32c8176d.
+//
+// Solidity: function deriveKey(string mnemonic, uint32 index, string language) pure returns(uint256 privateKey)
+func (_Vm *VmSession) DeriveKey0(mnemonic string, index uint32, language string) (*big.Int, error) {
+	return _Vm.Contract.DeriveKey0(&_Vm.CallOpts, mnemonic, index, language)
+}
+
+// DeriveKey0 is a free data retrieval call binding the contract method 0x32c8176d.
+//
+// Solidity: function deriveKey(string mnemonic, uint32 index, string language) pure returns(uint256 privateKey)
+func (_Vm *VmCallerSession) DeriveKey0(mnemonic string, index uint32, language string) (*big.Int, error) {
+	return _Vm.Contract.DeriveKey0(&_Vm.CallOpts, mnemonic, index, language)
+}
+
+// DeriveKey1 is a free data retrieval call binding the contract method 0x6229498b.
+//
+// Solidity: function deriveKey(string mnemonic, uint32 index) pure returns(uint256 privateKey)
+func (_Vm *VmCaller) DeriveKey1(opts *bind.CallOpts, mnemonic string, index uint32) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "deriveKey1", mnemonic, index)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// DeriveKey1 is a free data retrieval call binding the contract method 0x6229498b.
+//
+// Solidity: function deriveKey(string mnemonic, uint32 index) pure returns(uint256 privateKey)
+func (_Vm *VmSession) DeriveKey1(mnemonic string, index uint32) (*big.Int, error) {
+	return _Vm.Contract.DeriveKey1(&_Vm.CallOpts, mnemonic, index)
+}
+
+// DeriveKey1 is a free data retrieval call binding the contract method 0x6229498b.
+//
+// Solidity: function deriveKey(string mnemonic, uint32 index) pure returns(uint256 privateKey)
+func (_Vm *VmCallerSession) DeriveKey1(mnemonic string, index uint32) (*big.Int, error) {
+	return _Vm.Contract.DeriveKey1(&_Vm.CallOpts, mnemonic, index)
+}
+
+// DeriveKey2 is a free data retrieval call binding the contract method 0x6bcb2c1b.
+//
+// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index) pure returns(uint256 privateKey)
+func (_Vm *VmCaller) DeriveKey2(opts *bind.CallOpts, mnemonic string, derivationPath string, index uint32) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "deriveKey2", mnemonic, derivationPath, index)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// DeriveKey2 is a free data retrieval call binding the contract method 0x6bcb2c1b.
+//
+// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index) pure returns(uint256 privateKey)
+func (_Vm *VmSession) DeriveKey2(mnemonic string, derivationPath string, index uint32) (*big.Int, error) {
+	return _Vm.Contract.DeriveKey2(&_Vm.CallOpts, mnemonic, derivationPath, index)
+}
+
+// DeriveKey2 is a free data retrieval call binding the contract method 0x6bcb2c1b.
+//
+// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index) pure returns(uint256 privateKey)
+func (_Vm *VmCallerSession) DeriveKey2(mnemonic string, derivationPath string, index uint32) (*big.Int, error) {
+	return _Vm.Contract.DeriveKey2(&_Vm.CallOpts, mnemonic, derivationPath, index)
+}
+
+// EnsNamehash is a free data retrieval call binding the contract method 0x8c374c65.
+//
+// Solidity: function ensNamehash(string name) pure returns(bytes32)
+func (_Vm *VmCaller) EnsNamehash(opts *bind.CallOpts, name string) ([32]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "ensNamehash", name)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// EnsNamehash is a free data retrieval call binding the contract method 0x8c374c65.
+//
+// Solidity: function ensNamehash(string name) pure returns(bytes32)
+func (_Vm *VmSession) EnsNamehash(name string) ([32]byte, error) {
+	return _Vm.Contract.EnsNamehash(&_Vm.CallOpts, name)
+}
+
+// EnsNamehash is a free data retrieval call binding the contract method 0x8c374c65.
+//
+// Solidity: function ensNamehash(string name) pure returns(bytes32)
+func (_Vm *VmCallerSession) EnsNamehash(name string) ([32]byte, error) {
+	return _Vm.Contract.EnsNamehash(&_Vm.CallOpts, name)
+}
+
+// EnvAddress is a free data retrieval call binding the contract method 0x350d56bf.
+//
+// Solidity: function envAddress(string name) view returns(address value)
+func (_Vm *VmCaller) EnvAddress(opts *bind.CallOpts, name string) (common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envAddress", name)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// EnvAddress is a free data retrieval call binding the contract method 0x350d56bf.
+//
+// Solidity: function envAddress(string name) view returns(address value)
+func (_Vm *VmSession) EnvAddress(name string) (common.Address, error) {
+	return _Vm.Contract.EnvAddress(&_Vm.CallOpts, name)
+}
+
+// EnvAddress is a free data retrieval call binding the contract method 0x350d56bf.
+//
+// Solidity: function envAddress(string name) view returns(address value)
+func (_Vm *VmCallerSession) EnvAddress(name string) (common.Address, error) {
+	return _Vm.Contract.EnvAddress(&_Vm.CallOpts, name)
+}
+
+// EnvAddress0 is a free data retrieval call binding the contract method 0xad31b9fa.
+//
+// Solidity: function envAddress(string name, string delim) view returns(address[] value)
+func (_Vm *VmCaller) EnvAddress0(opts *bind.CallOpts, name string, delim string) ([]common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envAddress0", name, delim)
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// EnvAddress0 is a free data retrieval call binding the contract method 0xad31b9fa.
+//
+// Solidity: function envAddress(string name, string delim) view returns(address[] value)
+func (_Vm *VmSession) EnvAddress0(name string, delim string) ([]common.Address, error) {
+	return _Vm.Contract.EnvAddress0(&_Vm.CallOpts, name, delim)
+}
+
+// EnvAddress0 is a free data retrieval call binding the contract method 0xad31b9fa.
+//
+// Solidity: function envAddress(string name, string delim) view returns(address[] value)
+func (_Vm *VmCallerSession) EnvAddress0(name string, delim string) ([]common.Address, error) {
+	return _Vm.Contract.EnvAddress0(&_Vm.CallOpts, name, delim)
+}
+
+// EnvBool is a free data retrieval call binding the contract method 0x7ed1ec7d.
+//
+// Solidity: function envBool(string name) view returns(bool value)
+func (_Vm *VmCaller) EnvBool(opts *bind.CallOpts, name string) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envBool", name)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// EnvBool is a free data retrieval call binding the contract method 0x7ed1ec7d.
+//
+// Solidity: function envBool(string name) view returns(bool value)
+func (_Vm *VmSession) EnvBool(name string) (bool, error) {
+	return _Vm.Contract.EnvBool(&_Vm.CallOpts, name)
+}
+
+// EnvBool is a free data retrieval call binding the contract method 0x7ed1ec7d.
+//
+// Solidity: function envBool(string name) view returns(bool value)
+func (_Vm *VmCallerSession) EnvBool(name string) (bool, error) {
+	return _Vm.Contract.EnvBool(&_Vm.CallOpts, name)
+}
+
+// EnvBool0 is a free data retrieval call binding the contract method 0xaaaddeaf.
+//
+// Solidity: function envBool(string name, string delim) view returns(bool[] value)
+func (_Vm *VmCaller) EnvBool0(opts *bind.CallOpts, name string, delim string) ([]bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envBool0", name, delim)
+
+	if err != nil {
+		return *new([]bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool)
+
+	return out0, err
+
+}
+
+// EnvBool0 is a free data retrieval call binding the contract method 0xaaaddeaf.
+//
+// Solidity: function envBool(string name, string delim) view returns(bool[] value)
+func (_Vm *VmSession) EnvBool0(name string, delim string) ([]bool, error) {
+	return _Vm.Contract.EnvBool0(&_Vm.CallOpts, name, delim)
+}
+
+// EnvBool0 is a free data retrieval call binding the contract method 0xaaaddeaf.
+//
+// Solidity: function envBool(string name, string delim) view returns(bool[] value)
+func (_Vm *VmCallerSession) EnvBool0(name string, delim string) ([]bool, error) {
+	return _Vm.Contract.EnvBool0(&_Vm.CallOpts, name, delim)
+}
+
+// EnvBytes is a free data retrieval call binding the contract method 0x4d7baf06.
+//
+// Solidity: function envBytes(string name) view returns(bytes value)
+func (_Vm *VmCaller) EnvBytes(opts *bind.CallOpts, name string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envBytes", name)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// EnvBytes is a free data retrieval call binding the contract method 0x4d7baf06.
+//
+// Solidity: function envBytes(string name) view returns(bytes value)
+func (_Vm *VmSession) EnvBytes(name string) ([]byte, error) {
+	return _Vm.Contract.EnvBytes(&_Vm.CallOpts, name)
+}
+
+// EnvBytes is a free data retrieval call binding the contract method 0x4d7baf06.
+//
+// Solidity: function envBytes(string name) view returns(bytes value)
+func (_Vm *VmCallerSession) EnvBytes(name string) ([]byte, error) {
+	return _Vm.Contract.EnvBytes(&_Vm.CallOpts, name)
+}
+
+// EnvBytes0 is a free data retrieval call binding the contract method 0xddc2651b.
+//
+// Solidity: function envBytes(string name, string delim) view returns(bytes[] value)
+func (_Vm *VmCaller) EnvBytes0(opts *bind.CallOpts, name string, delim string) ([][]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envBytes0", name, delim)
+
+	if err != nil {
+		return *new([][]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte)
+
+	return out0, err
+
+}
+
+// EnvBytes0 is a free data retrieval call binding the contract method 0xddc2651b.
+//
+// Solidity: function envBytes(string name, string delim) view returns(bytes[] value)
+func (_Vm *VmSession) EnvBytes0(name string, delim string) ([][]byte, error) {
+	return _Vm.Contract.EnvBytes0(&_Vm.CallOpts, name, delim)
+}
+
+// EnvBytes0 is a free data retrieval call binding the contract method 0xddc2651b.
+//
+// Solidity: function envBytes(string name, string delim) view returns(bytes[] value)
+func (_Vm *VmCallerSession) EnvBytes0(name string, delim string) ([][]byte, error) {
+	return _Vm.Contract.EnvBytes0(&_Vm.CallOpts, name, delim)
+}
+
+// EnvBytes32 is a free data retrieval call binding the contract method 0x5af231c1.
+//
+// Solidity: function envBytes32(string name, string delim) view returns(bytes32[] value)
+func (_Vm *VmCaller) EnvBytes32(opts *bind.CallOpts, name string, delim string) ([][32]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envBytes32", name, delim)
+
+	if err != nil {
+		return *new([][32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte)
+
+	return out0, err
+
+}
+
+// EnvBytes32 is a free data retrieval call binding the contract method 0x5af231c1.
+//
+// Solidity: function envBytes32(string name, string delim) view returns(bytes32[] value)
+func (_Vm *VmSession) EnvBytes32(name string, delim string) ([][32]byte, error) {
+	return _Vm.Contract.EnvBytes32(&_Vm.CallOpts, name, delim)
+}
+
+// EnvBytes32 is a free data retrieval call binding the contract method 0x5af231c1.
+//
+// Solidity: function envBytes32(string name, string delim) view returns(bytes32[] value)
+func (_Vm *VmCallerSession) EnvBytes32(name string, delim string) ([][32]byte, error) {
+	return _Vm.Contract.EnvBytes32(&_Vm.CallOpts, name, delim)
+}
+
+// EnvBytes320 is a free data retrieval call binding the contract method 0x97949042.
+//
+// Solidity: function envBytes32(string name) view returns(bytes32 value)
+func (_Vm *VmCaller) EnvBytes320(opts *bind.CallOpts, name string) ([32]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envBytes320", name)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// EnvBytes320 is a free data retrieval call binding the contract method 0x97949042.
+//
+// Solidity: function envBytes32(string name) view returns(bytes32 value)
+func (_Vm *VmSession) EnvBytes320(name string) ([32]byte, error) {
+	return _Vm.Contract.EnvBytes320(&_Vm.CallOpts, name)
+}
+
+// EnvBytes320 is a free data retrieval call binding the contract method 0x97949042.
+//
+// Solidity: function envBytes32(string name) view returns(bytes32 value)
+func (_Vm *VmCallerSession) EnvBytes320(name string) ([32]byte, error) {
+	return _Vm.Contract.EnvBytes320(&_Vm.CallOpts, name)
+}
+
+// EnvExists is a free data retrieval call binding the contract method 0xce8365f9.
+//
+// Solidity: function envExists(string name) view returns(bool result)
+func (_Vm *VmCaller) EnvExists(opts *bind.CallOpts, name string) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envExists", name)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// EnvExists is a free data retrieval call binding the contract method 0xce8365f9.
+//
+// Solidity: function envExists(string name) view returns(bool result)
+func (_Vm *VmSession) EnvExists(name string) (bool, error) {
+	return _Vm.Contract.EnvExists(&_Vm.CallOpts, name)
+}
+
+// EnvExists is a free data retrieval call binding the contract method 0xce8365f9.
+//
+// Solidity: function envExists(string name) view returns(bool result)
+func (_Vm *VmCallerSession) EnvExists(name string) (bool, error) {
+	return _Vm.Contract.EnvExists(&_Vm.CallOpts, name)
+}
+
+// EnvInt is a free data retrieval call binding the contract method 0x42181150.
+//
+// Solidity: function envInt(string name, string delim) view returns(int256[] value)
+func (_Vm *VmCaller) EnvInt(opts *bind.CallOpts, name string, delim string) ([]*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envInt", name, delim)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// EnvInt is a free data retrieval call binding the contract method 0x42181150.
+//
+// Solidity: function envInt(string name, string delim) view returns(int256[] value)
+func (_Vm *VmSession) EnvInt(name string, delim string) ([]*big.Int, error) {
+	return _Vm.Contract.EnvInt(&_Vm.CallOpts, name, delim)
+}
+
+// EnvInt is a free data retrieval call binding the contract method 0x42181150.
+//
+// Solidity: function envInt(string name, string delim) view returns(int256[] value)
+func (_Vm *VmCallerSession) EnvInt(name string, delim string) ([]*big.Int, error) {
+	return _Vm.Contract.EnvInt(&_Vm.CallOpts, name, delim)
+}
+
+// EnvInt0 is a free data retrieval call binding the contract method 0x892a0c61.
+//
+// Solidity: function envInt(string name) view returns(int256 value)
+func (_Vm *VmCaller) EnvInt0(opts *bind.CallOpts, name string) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envInt0", name)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// EnvInt0 is a free data retrieval call binding the contract method 0x892a0c61.
+//
+// Solidity: function envInt(string name) view returns(int256 value)
+func (_Vm *VmSession) EnvInt0(name string) (*big.Int, error) {
+	return _Vm.Contract.EnvInt0(&_Vm.CallOpts, name)
+}
+
+// EnvInt0 is a free data retrieval call binding the contract method 0x892a0c61.
+//
+// Solidity: function envInt(string name) view returns(int256 value)
+func (_Vm *VmCallerSession) EnvInt0(name string) (*big.Int, error) {
+	return _Vm.Contract.EnvInt0(&_Vm.CallOpts, name)
+}
+
+// EnvOr is a free data retrieval call binding the contract method 0x2281f367.
+//
+// Solidity: function envOr(string name, string delim, bytes32[] defaultValue) view returns(bytes32[] value)
+func (_Vm *VmCaller) EnvOr(opts *bind.CallOpts, name string, delim string, defaultValue [][32]byte) ([][32]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([][32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte)
+
+	return out0, err
+
+}
+
+// EnvOr is a free data retrieval call binding the contract method 0x2281f367.
+//
+// Solidity: function envOr(string name, string delim, bytes32[] defaultValue) view returns(bytes32[] value)
+func (_Vm *VmSession) EnvOr(name string, delim string, defaultValue [][32]byte) ([][32]byte, error) {
+	return _Vm.Contract.EnvOr(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr is a free data retrieval call binding the contract method 0x2281f367.
+//
+// Solidity: function envOr(string name, string delim, bytes32[] defaultValue) view returns(bytes32[] value)
+func (_Vm *VmCallerSession) EnvOr(name string, delim string, defaultValue [][32]byte) ([][32]byte, error) {
+	return _Vm.Contract.EnvOr(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr0 is a free data retrieval call binding the contract method 0x4700d74b.
+//
+// Solidity: function envOr(string name, string delim, int256[] defaultValue) view returns(int256[] value)
+func (_Vm *VmCaller) EnvOr0(opts *bind.CallOpts, name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr0", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// EnvOr0 is a free data retrieval call binding the contract method 0x4700d74b.
+//
+// Solidity: function envOr(string name, string delim, int256[] defaultValue) view returns(int256[] value)
+func (_Vm *VmSession) EnvOr0(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) {
+	return _Vm.Contract.EnvOr0(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr0 is a free data retrieval call binding the contract method 0x4700d74b.
+//
+// Solidity: function envOr(string name, string delim, int256[] defaultValue) view returns(int256[] value)
+func (_Vm *VmCallerSession) EnvOr0(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) {
+	return _Vm.Contract.EnvOr0(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr1 is a free data retrieval call binding the contract method 0x4777f3cf.
+//
+// Solidity: function envOr(string name, bool defaultValue) view returns(bool value)
+func (_Vm *VmCaller) EnvOr1(opts *bind.CallOpts, name string, defaultValue bool) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr1", name, defaultValue)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// EnvOr1 is a free data retrieval call binding the contract method 0x4777f3cf.
+//
+// Solidity: function envOr(string name, bool defaultValue) view returns(bool value)
+func (_Vm *VmSession) EnvOr1(name string, defaultValue bool) (bool, error) {
+	return _Vm.Contract.EnvOr1(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvOr1 is a free data retrieval call binding the contract method 0x4777f3cf.
+//
+// Solidity: function envOr(string name, bool defaultValue) view returns(bool value)
+func (_Vm *VmCallerSession) EnvOr1(name string, defaultValue bool) (bool, error) {
+	return _Vm.Contract.EnvOr1(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvOr10 is a free data retrieval call binding the contract method 0xc74e9deb.
+//
+// Solidity: function envOr(string name, string delim, address[] defaultValue) view returns(address[] value)
+func (_Vm *VmCaller) EnvOr10(opts *bind.CallOpts, name string, delim string, defaultValue []common.Address) ([]common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr10", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// EnvOr10 is a free data retrieval call binding the contract method 0xc74e9deb.
+//
+// Solidity: function envOr(string name, string delim, address[] defaultValue) view returns(address[] value)
+func (_Vm *VmSession) EnvOr10(name string, delim string, defaultValue []common.Address) ([]common.Address, error) {
+	return _Vm.Contract.EnvOr10(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr10 is a free data retrieval call binding the contract method 0xc74e9deb.
+//
+// Solidity: function envOr(string name, string delim, address[] defaultValue) view returns(address[] value)
+func (_Vm *VmCallerSession) EnvOr10(name string, delim string, defaultValue []common.Address) ([]common.Address, error) {
+	return _Vm.Contract.EnvOr10(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr11 is a free data retrieval call binding the contract method 0xd145736c.
+//
+// Solidity: function envOr(string name, string defaultValue) view returns(string value)
+func (_Vm *VmCaller) EnvOr11(opts *bind.CallOpts, name string, defaultValue string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr11", name, defaultValue)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// EnvOr11 is a free data retrieval call binding the contract method 0xd145736c.
+//
+// Solidity: function envOr(string name, string defaultValue) view returns(string value)
+func (_Vm *VmSession) EnvOr11(name string, defaultValue string) (string, error) {
+	return _Vm.Contract.EnvOr11(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvOr11 is a free data retrieval call binding the contract method 0xd145736c.
+//
+// Solidity: function envOr(string name, string defaultValue) view returns(string value)
+func (_Vm *VmCallerSession) EnvOr11(name string, defaultValue string) (string, error) {
+	return _Vm.Contract.EnvOr11(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvOr12 is a free data retrieval call binding the contract method 0xeb85e83b.
+//
+// Solidity: function envOr(string name, string delim, bool[] defaultValue) view returns(bool[] value)
+func (_Vm *VmCaller) EnvOr12(opts *bind.CallOpts, name string, delim string, defaultValue []bool) ([]bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr12", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([]bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool)
+
+	return out0, err
+
+}
+
+// EnvOr12 is a free data retrieval call binding the contract method 0xeb85e83b.
+//
+// Solidity: function envOr(string name, string delim, bool[] defaultValue) view returns(bool[] value)
+func (_Vm *VmSession) EnvOr12(name string, delim string, defaultValue []bool) ([]bool, error) {
+	return _Vm.Contract.EnvOr12(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr12 is a free data retrieval call binding the contract method 0xeb85e83b.
+//
+// Solidity: function envOr(string name, string delim, bool[] defaultValue) view returns(bool[] value)
+func (_Vm *VmCallerSession) EnvOr12(name string, delim string, defaultValue []bool) ([]bool, error) {
+	return _Vm.Contract.EnvOr12(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr2 is a free data retrieval call binding the contract method 0x561fe540.
+//
+// Solidity: function envOr(string name, address defaultValue) view returns(address value)
+func (_Vm *VmCaller) EnvOr2(opts *bind.CallOpts, name string, defaultValue common.Address) (common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr2", name, defaultValue)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// EnvOr2 is a free data retrieval call binding the contract method 0x561fe540.
+//
+// Solidity: function envOr(string name, address defaultValue) view returns(address value)
+func (_Vm *VmSession) EnvOr2(name string, defaultValue common.Address) (common.Address, error) {
+	return _Vm.Contract.EnvOr2(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvOr2 is a free data retrieval call binding the contract method 0x561fe540.
+//
+// Solidity: function envOr(string name, address defaultValue) view returns(address value)
+func (_Vm *VmCallerSession) EnvOr2(name string, defaultValue common.Address) (common.Address, error) {
+	return _Vm.Contract.EnvOr2(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvOr3 is a free data retrieval call binding the contract method 0x5e97348f.
+//
+// Solidity: function envOr(string name, uint256 defaultValue) view returns(uint256 value)
+func (_Vm *VmCaller) EnvOr3(opts *bind.CallOpts, name string, defaultValue *big.Int) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr3", name, defaultValue)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// EnvOr3 is a free data retrieval call binding the contract method 0x5e97348f.
+//
+// Solidity: function envOr(string name, uint256 defaultValue) view returns(uint256 value)
+func (_Vm *VmSession) EnvOr3(name string, defaultValue *big.Int) (*big.Int, error) {
+	return _Vm.Contract.EnvOr3(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvOr3 is a free data retrieval call binding the contract method 0x5e97348f.
+//
+// Solidity: function envOr(string name, uint256 defaultValue) view returns(uint256 value)
+func (_Vm *VmCallerSession) EnvOr3(name string, defaultValue *big.Int) (*big.Int, error) {
+	return _Vm.Contract.EnvOr3(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvOr4 is a free data retrieval call binding the contract method 0x64bc3e64.
+//
+// Solidity: function envOr(string name, string delim, bytes[] defaultValue) view returns(bytes[] value)
+func (_Vm *VmCaller) EnvOr4(opts *bind.CallOpts, name string, delim string, defaultValue [][]byte) ([][]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr4", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([][]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte)
+
+	return out0, err
+
+}
+
+// EnvOr4 is a free data retrieval call binding the contract method 0x64bc3e64.
+//
+// Solidity: function envOr(string name, string delim, bytes[] defaultValue) view returns(bytes[] value)
+func (_Vm *VmSession) EnvOr4(name string, delim string, defaultValue [][]byte) ([][]byte, error) {
+	return _Vm.Contract.EnvOr4(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr4 is a free data retrieval call binding the contract method 0x64bc3e64.
+//
+// Solidity: function envOr(string name, string delim, bytes[] defaultValue) view returns(bytes[] value)
+func (_Vm *VmCallerSession) EnvOr4(name string, delim string, defaultValue [][]byte) ([][]byte, error) {
+	return _Vm.Contract.EnvOr4(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr5 is a free data retrieval call binding the contract method 0x74318528.
+//
+// Solidity: function envOr(string name, string delim, uint256[] defaultValue) view returns(uint256[] value)
+func (_Vm *VmCaller) EnvOr5(opts *bind.CallOpts, name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr5", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// EnvOr5 is a free data retrieval call binding the contract method 0x74318528.
+//
+// Solidity: function envOr(string name, string delim, uint256[] defaultValue) view returns(uint256[] value)
+func (_Vm *VmSession) EnvOr5(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) {
+	return _Vm.Contract.EnvOr5(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr5 is a free data retrieval call binding the contract method 0x74318528.
+//
+// Solidity: function envOr(string name, string delim, uint256[] defaultValue) view returns(uint256[] value)
+func (_Vm *VmCallerSession) EnvOr5(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) {
+	return _Vm.Contract.EnvOr5(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr6 is a free data retrieval call binding the contract method 0x859216bc.
+//
+// Solidity: function envOr(string name, string delim, string[] defaultValue) view returns(string[] value)
+func (_Vm *VmCaller) EnvOr6(opts *bind.CallOpts, name string, delim string, defaultValue []string) ([]string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr6", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// EnvOr6 is a free data retrieval call binding the contract method 0x859216bc.
+//
+// Solidity: function envOr(string name, string delim, string[] defaultValue) view returns(string[] value)
+func (_Vm *VmSession) EnvOr6(name string, delim string, defaultValue []string) ([]string, error) {
+	return _Vm.Contract.EnvOr6(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr6 is a free data retrieval call binding the contract method 0x859216bc.
+//
+// Solidity: function envOr(string name, string delim, string[] defaultValue) view returns(string[] value)
+func (_Vm *VmCallerSession) EnvOr6(name string, delim string, defaultValue []string) ([]string, error) {
+	return _Vm.Contract.EnvOr6(&_Vm.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr7 is a free data retrieval call binding the contract method 0xb3e47705.
+//
+// Solidity: function envOr(string name, bytes defaultValue) view returns(bytes value)
+func (_Vm *VmCaller) EnvOr7(opts *bind.CallOpts, name string, defaultValue []byte) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr7", name, defaultValue)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// EnvOr7 is a free data retrieval call binding the contract method 0xb3e47705.
+//
+// Solidity: function envOr(string name, bytes defaultValue) view returns(bytes value)
+func (_Vm *VmSession) EnvOr7(name string, defaultValue []byte) ([]byte, error) {
+	return _Vm.Contract.EnvOr7(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvOr7 is a free data retrieval call binding the contract method 0xb3e47705.
+//
+// Solidity: function envOr(string name, bytes defaultValue) view returns(bytes value)
+func (_Vm *VmCallerSession) EnvOr7(name string, defaultValue []byte) ([]byte, error) {
+	return _Vm.Contract.EnvOr7(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvOr8 is a free data retrieval call binding the contract method 0xb4a85892.
+//
+// Solidity: function envOr(string name, bytes32 defaultValue) view returns(bytes32 value)
+func (_Vm *VmCaller) EnvOr8(opts *bind.CallOpts, name string, defaultValue [32]byte) ([32]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr8", name, defaultValue)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// EnvOr8 is a free data retrieval call binding the contract method 0xb4a85892.
+//
+// Solidity: function envOr(string name, bytes32 defaultValue) view returns(bytes32 value)
+func (_Vm *VmSession) EnvOr8(name string, defaultValue [32]byte) ([32]byte, error) {
+	return _Vm.Contract.EnvOr8(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvOr8 is a free data retrieval call binding the contract method 0xb4a85892.
+//
+// Solidity: function envOr(string name, bytes32 defaultValue) view returns(bytes32 value)
+func (_Vm *VmCallerSession) EnvOr8(name string, defaultValue [32]byte) ([32]byte, error) {
+	return _Vm.Contract.EnvOr8(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvOr9 is a free data retrieval call binding the contract method 0xbbcb713e.
+//
+// Solidity: function envOr(string name, int256 defaultValue) view returns(int256 value)
+func (_Vm *VmCaller) EnvOr9(opts *bind.CallOpts, name string, defaultValue *big.Int) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envOr9", name, defaultValue)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// EnvOr9 is a free data retrieval call binding the contract method 0xbbcb713e.
+//
+// Solidity: function envOr(string name, int256 defaultValue) view returns(int256 value)
+func (_Vm *VmSession) EnvOr9(name string, defaultValue *big.Int) (*big.Int, error) {
+	return _Vm.Contract.EnvOr9(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvOr9 is a free data retrieval call binding the contract method 0xbbcb713e.
+//
+// Solidity: function envOr(string name, int256 defaultValue) view returns(int256 value)
+func (_Vm *VmCallerSession) EnvOr9(name string, defaultValue *big.Int) (*big.Int, error) {
+	return _Vm.Contract.EnvOr9(&_Vm.CallOpts, name, defaultValue)
+}
+
+// EnvString is a free data retrieval call binding the contract method 0x14b02bc9.
+//
+// Solidity: function envString(string name, string delim) view returns(string[] value)
+func (_Vm *VmCaller) EnvString(opts *bind.CallOpts, name string, delim string) ([]string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envString", name, delim)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// EnvString is a free data retrieval call binding the contract method 0x14b02bc9.
+//
+// Solidity: function envString(string name, string delim) view returns(string[] value)
+func (_Vm *VmSession) EnvString(name string, delim string) ([]string, error) {
+	return _Vm.Contract.EnvString(&_Vm.CallOpts, name, delim)
+}
+
+// EnvString is a free data retrieval call binding the contract method 0x14b02bc9.
+//
+// Solidity: function envString(string name, string delim) view returns(string[] value)
+func (_Vm *VmCallerSession) EnvString(name string, delim string) ([]string, error) {
+	return _Vm.Contract.EnvString(&_Vm.CallOpts, name, delim)
+}
+
+// EnvString0 is a free data retrieval call binding the contract method 0xf877cb19.
+//
+// Solidity: function envString(string name) view returns(string value)
+func (_Vm *VmCaller) EnvString0(opts *bind.CallOpts, name string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envString0", name)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// EnvString0 is a free data retrieval call binding the contract method 0xf877cb19.
+//
+// Solidity: function envString(string name) view returns(string value)
+func (_Vm *VmSession) EnvString0(name string) (string, error) {
+	return _Vm.Contract.EnvString0(&_Vm.CallOpts, name)
+}
+
+// EnvString0 is a free data retrieval call binding the contract method 0xf877cb19.
+//
+// Solidity: function envString(string name) view returns(string value)
+func (_Vm *VmCallerSession) EnvString0(name string) (string, error) {
+	return _Vm.Contract.EnvString0(&_Vm.CallOpts, name)
+}
+
+// EnvUint is a free data retrieval call binding the contract method 0xc1978d1f.
+//
+// Solidity: function envUint(string name) view returns(uint256 value)
+func (_Vm *VmCaller) EnvUint(opts *bind.CallOpts, name string) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envUint", name)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// EnvUint is a free data retrieval call binding the contract method 0xc1978d1f.
+//
+// Solidity: function envUint(string name) view returns(uint256 value)
+func (_Vm *VmSession) EnvUint(name string) (*big.Int, error) {
+	return _Vm.Contract.EnvUint(&_Vm.CallOpts, name)
+}
+
+// EnvUint is a free data retrieval call binding the contract method 0xc1978d1f.
+//
+// Solidity: function envUint(string name) view returns(uint256 value)
+func (_Vm *VmCallerSession) EnvUint(name string) (*big.Int, error) {
+	return _Vm.Contract.EnvUint(&_Vm.CallOpts, name)
+}
+
+// EnvUint0 is a free data retrieval call binding the contract method 0xf3dec099.
+//
+// Solidity: function envUint(string name, string delim) view returns(uint256[] value)
+func (_Vm *VmCaller) EnvUint0(opts *bind.CallOpts, name string, delim string) ([]*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "envUint0", name, delim)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// EnvUint0 is a free data retrieval call binding the contract method 0xf3dec099.
+//
+// Solidity: function envUint(string name, string delim) view returns(uint256[] value)
+func (_Vm *VmSession) EnvUint0(name string, delim string) ([]*big.Int, error) {
+	return _Vm.Contract.EnvUint0(&_Vm.CallOpts, name, delim)
+}
+
+// EnvUint0 is a free data retrieval call binding the contract method 0xf3dec099.
+//
+// Solidity: function envUint(string name, string delim) view returns(uint256[] value)
+func (_Vm *VmCallerSession) EnvUint0(name string, delim string) ([]*big.Int, error) {
+	return _Vm.Contract.EnvUint0(&_Vm.CallOpts, name, delim)
+}
+
+// Exists is a free data retrieval call binding the contract method 0x261a323e.
+//
+// Solidity: function exists(string path) view returns(bool result)
+func (_Vm *VmCaller) Exists(opts *bind.CallOpts, path string) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "exists", path)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// Exists is a free data retrieval call binding the contract method 0x261a323e.
+//
+// Solidity: function exists(string path) view returns(bool result)
+func (_Vm *VmSession) Exists(path string) (bool, error) {
+	return _Vm.Contract.Exists(&_Vm.CallOpts, path)
+}
+
+// Exists is a free data retrieval call binding the contract method 0x261a323e.
+//
+// Solidity: function exists(string path) view returns(bool result)
+func (_Vm *VmCallerSession) Exists(path string) (bool, error) {
+	return _Vm.Contract.Exists(&_Vm.CallOpts, path)
+}
+
+// FoundryVersionAtLeast is a free data retrieval call binding the contract method 0x6248be1f.
+//
+// Solidity: function foundryVersionAtLeast(string version) view returns(bool)
+func (_Vm *VmCaller) FoundryVersionAtLeast(opts *bind.CallOpts, version string) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "foundryVersionAtLeast", version)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// FoundryVersionAtLeast is a free data retrieval call binding the contract method 0x6248be1f.
+//
+// Solidity: function foundryVersionAtLeast(string version) view returns(bool)
+func (_Vm *VmSession) FoundryVersionAtLeast(version string) (bool, error) {
+	return _Vm.Contract.FoundryVersionAtLeast(&_Vm.CallOpts, version)
+}
+
+// FoundryVersionAtLeast is a free data retrieval call binding the contract method 0x6248be1f.
+//
+// Solidity: function foundryVersionAtLeast(string version) view returns(bool)
+func (_Vm *VmCallerSession) FoundryVersionAtLeast(version string) (bool, error) {
+	return _Vm.Contract.FoundryVersionAtLeast(&_Vm.CallOpts, version)
+}
+
+// FoundryVersionCmp is a free data retrieval call binding the contract method 0xca7b0a09.
+//
+// Solidity: function foundryVersionCmp(string version) view returns(int256)
+func (_Vm *VmCaller) FoundryVersionCmp(opts *bind.CallOpts, version string) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "foundryVersionCmp", version)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// FoundryVersionCmp is a free data retrieval call binding the contract method 0xca7b0a09.
+//
+// Solidity: function foundryVersionCmp(string version) view returns(int256)
+func (_Vm *VmSession) FoundryVersionCmp(version string) (*big.Int, error) {
+	return _Vm.Contract.FoundryVersionCmp(&_Vm.CallOpts, version)
+}
+
+// FoundryVersionCmp is a free data retrieval call binding the contract method 0xca7b0a09.
+//
+// Solidity: function foundryVersionCmp(string version) view returns(int256)
+func (_Vm *VmCallerSession) FoundryVersionCmp(version string) (*big.Int, error) {
+	return _Vm.Contract.FoundryVersionCmp(&_Vm.CallOpts, version)
+}
+
+// FsMetadata is a free data retrieval call binding the contract method 0xaf368a08.
+//
+// Solidity: function fsMetadata(string path) view returns((bool,bool,uint256,bool,uint256,uint256,uint256) metadata)
+func (_Vm *VmCaller) FsMetadata(opts *bind.CallOpts, path string) (VmSafeFsMetadata, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "fsMetadata", path)
+
+	if err != nil {
+		return *new(VmSafeFsMetadata), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(VmSafeFsMetadata)).(*VmSafeFsMetadata)
+
+	return out0, err
+
+}
+
+// FsMetadata is a free data retrieval call binding the contract method 0xaf368a08.
+//
+// Solidity: function fsMetadata(string path) view returns((bool,bool,uint256,bool,uint256,uint256,uint256) metadata)
+func (_Vm *VmSession) FsMetadata(path string) (VmSafeFsMetadata, error) {
+	return _Vm.Contract.FsMetadata(&_Vm.CallOpts, path)
+}
+
+// FsMetadata is a free data retrieval call binding the contract method 0xaf368a08.
+//
+// Solidity: function fsMetadata(string path) view returns((bool,bool,uint256,bool,uint256,uint256,uint256) metadata)
+func (_Vm *VmCallerSession) FsMetadata(path string) (VmSafeFsMetadata, error) {
+	return _Vm.Contract.FsMetadata(&_Vm.CallOpts, path)
+}
+
+// GetArtifactPathByCode is a free data retrieval call binding the contract method 0xeb74848c.
+//
+// Solidity: function getArtifactPathByCode(bytes code) view returns(string path)
+func (_Vm *VmCaller) GetArtifactPathByCode(opts *bind.CallOpts, code []byte) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getArtifactPathByCode", code)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetArtifactPathByCode is a free data retrieval call binding the contract method 0xeb74848c.
+//
+// Solidity: function getArtifactPathByCode(bytes code) view returns(string path)
+func (_Vm *VmSession) GetArtifactPathByCode(code []byte) (string, error) {
+	return _Vm.Contract.GetArtifactPathByCode(&_Vm.CallOpts, code)
+}
+
+// GetArtifactPathByCode is a free data retrieval call binding the contract method 0xeb74848c.
+//
+// Solidity: function getArtifactPathByCode(bytes code) view returns(string path)
+func (_Vm *VmCallerSession) GetArtifactPathByCode(code []byte) (string, error) {
+	return _Vm.Contract.GetArtifactPathByCode(&_Vm.CallOpts, code)
+}
+
+// GetArtifactPathByDeployedCode is a free data retrieval call binding the contract method 0x6d853ba5.
+//
+// Solidity: function getArtifactPathByDeployedCode(bytes deployedCode) view returns(string path)
+func (_Vm *VmCaller) GetArtifactPathByDeployedCode(opts *bind.CallOpts, deployedCode []byte) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getArtifactPathByDeployedCode", deployedCode)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetArtifactPathByDeployedCode is a free data retrieval call binding the contract method 0x6d853ba5.
+//
+// Solidity: function getArtifactPathByDeployedCode(bytes deployedCode) view returns(string path)
+func (_Vm *VmSession) GetArtifactPathByDeployedCode(deployedCode []byte) (string, error) {
+	return _Vm.Contract.GetArtifactPathByDeployedCode(&_Vm.CallOpts, deployedCode)
+}
+
+// GetArtifactPathByDeployedCode is a free data retrieval call binding the contract method 0x6d853ba5.
+//
+// Solidity: function getArtifactPathByDeployedCode(bytes deployedCode) view returns(string path)
+func (_Vm *VmCallerSession) GetArtifactPathByDeployedCode(deployedCode []byte) (string, error) {
+	return _Vm.Contract.GetArtifactPathByDeployedCode(&_Vm.CallOpts, deployedCode)
+}
+
+// GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7.
+//
+// Solidity: function getBlobBaseFee() view returns(uint256 blobBaseFee)
+func (_Vm *VmCaller) GetBlobBaseFee(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getBlobBaseFee")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7.
+//
+// Solidity: function getBlobBaseFee() view returns(uint256 blobBaseFee)
+func (_Vm *VmSession) GetBlobBaseFee() (*big.Int, error) {
+	return _Vm.Contract.GetBlobBaseFee(&_Vm.CallOpts)
+}
+
+// GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7.
+//
+// Solidity: function getBlobBaseFee() view returns(uint256 blobBaseFee)
+func (_Vm *VmCallerSession) GetBlobBaseFee() (*big.Int, error) {
+	return _Vm.Contract.GetBlobBaseFee(&_Vm.CallOpts)
+}
+
+// GetBlobhashes is a free data retrieval call binding the contract method 0xf56ff18b.
+//
+// Solidity: function getBlobhashes() view returns(bytes32[] hashes)
+func (_Vm *VmCaller) GetBlobhashes(opts *bind.CallOpts) ([][32]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getBlobhashes")
+
+	if err != nil {
+		return *new([][32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte)
+
+	return out0, err
+
+}
+
+// GetBlobhashes is a free data retrieval call binding the contract method 0xf56ff18b.
+//
+// Solidity: function getBlobhashes() view returns(bytes32[] hashes)
+func (_Vm *VmSession) GetBlobhashes() ([][32]byte, error) {
+	return _Vm.Contract.GetBlobhashes(&_Vm.CallOpts)
+}
+
+// GetBlobhashes is a free data retrieval call binding the contract method 0xf56ff18b.
+//
+// Solidity: function getBlobhashes() view returns(bytes32[] hashes)
+func (_Vm *VmCallerSession) GetBlobhashes() ([][32]byte, error) {
+	return _Vm.Contract.GetBlobhashes(&_Vm.CallOpts)
+}
+
+// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c.
+//
+// Solidity: function getBlockNumber() view returns(uint256 height)
+func (_Vm *VmCaller) GetBlockNumber(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getBlockNumber")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c.
+//
+// Solidity: function getBlockNumber() view returns(uint256 height)
+func (_Vm *VmSession) GetBlockNumber() (*big.Int, error) {
+	return _Vm.Contract.GetBlockNumber(&_Vm.CallOpts)
+}
+
+// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c.
+//
+// Solidity: function getBlockNumber() view returns(uint256 height)
+func (_Vm *VmCallerSession) GetBlockNumber() (*big.Int, error) {
+	return _Vm.Contract.GetBlockNumber(&_Vm.CallOpts)
+}
+
+// GetBlockTimestamp is a free data retrieval call binding the contract method 0x796b89b9.
+//
+// Solidity: function getBlockTimestamp() view returns(uint256 timestamp)
+func (_Vm *VmCaller) GetBlockTimestamp(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getBlockTimestamp")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetBlockTimestamp is a free data retrieval call binding the contract method 0x796b89b9.
+//
+// Solidity: function getBlockTimestamp() view returns(uint256 timestamp)
+func (_Vm *VmSession) GetBlockTimestamp() (*big.Int, error) {
+	return _Vm.Contract.GetBlockTimestamp(&_Vm.CallOpts)
+}
+
+// GetBlockTimestamp is a free data retrieval call binding the contract method 0x796b89b9.
+//
+// Solidity: function getBlockTimestamp() view returns(uint256 timestamp)
+func (_Vm *VmCallerSession) GetBlockTimestamp() (*big.Int, error) {
+	return _Vm.Contract.GetBlockTimestamp(&_Vm.CallOpts)
+}
+
+// GetBroadcast is a free data retrieval call binding the contract method 0x3dc90cb3.
+//
+// Solidity: function getBroadcast(string contractName, uint64 chainId, uint8 txType) view returns((bytes32,uint8,address,uint64,bool))
+func (_Vm *VmCaller) GetBroadcast(opts *bind.CallOpts, contractName string, chainId uint64, txType uint8) (VmSafeBroadcastTxSummary, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getBroadcast", contractName, chainId, txType)
+
+	if err != nil {
+		return *new(VmSafeBroadcastTxSummary), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(VmSafeBroadcastTxSummary)).(*VmSafeBroadcastTxSummary)
+
+	return out0, err
+
+}
+
+// GetBroadcast is a free data retrieval call binding the contract method 0x3dc90cb3.
+//
+// Solidity: function getBroadcast(string contractName, uint64 chainId, uint8 txType) view returns((bytes32,uint8,address,uint64,bool))
+func (_Vm *VmSession) GetBroadcast(contractName string, chainId uint64, txType uint8) (VmSafeBroadcastTxSummary, error) {
+	return _Vm.Contract.GetBroadcast(&_Vm.CallOpts, contractName, chainId, txType)
+}
+
+// GetBroadcast is a free data retrieval call binding the contract method 0x3dc90cb3.
+//
+// Solidity: function getBroadcast(string contractName, uint64 chainId, uint8 txType) view returns((bytes32,uint8,address,uint64,bool))
+func (_Vm *VmCallerSession) GetBroadcast(contractName string, chainId uint64, txType uint8) (VmSafeBroadcastTxSummary, error) {
+	return _Vm.Contract.GetBroadcast(&_Vm.CallOpts, contractName, chainId, txType)
+}
+
+// GetBroadcasts is a free data retrieval call binding the contract method 0xf2fa4a26.
+//
+// Solidity: function getBroadcasts(string contractName, uint64 chainId) view returns((bytes32,uint8,address,uint64,bool)[])
+func (_Vm *VmCaller) GetBroadcasts(opts *bind.CallOpts, contractName string, chainId uint64) ([]VmSafeBroadcastTxSummary, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getBroadcasts", contractName, chainId)
+
+	if err != nil {
+		return *new([]VmSafeBroadcastTxSummary), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]VmSafeBroadcastTxSummary)).(*[]VmSafeBroadcastTxSummary)
+
+	return out0, err
+
+}
+
+// GetBroadcasts is a free data retrieval call binding the contract method 0xf2fa4a26.
+//
+// Solidity: function getBroadcasts(string contractName, uint64 chainId) view returns((bytes32,uint8,address,uint64,bool)[])
+func (_Vm *VmSession) GetBroadcasts(contractName string, chainId uint64) ([]VmSafeBroadcastTxSummary, error) {
+	return _Vm.Contract.GetBroadcasts(&_Vm.CallOpts, contractName, chainId)
+}
+
+// GetBroadcasts is a free data retrieval call binding the contract method 0xf2fa4a26.
+//
+// Solidity: function getBroadcasts(string contractName, uint64 chainId) view returns((bytes32,uint8,address,uint64,bool)[])
+func (_Vm *VmCallerSession) GetBroadcasts(contractName string, chainId uint64) ([]VmSafeBroadcastTxSummary, error) {
+	return _Vm.Contract.GetBroadcasts(&_Vm.CallOpts, contractName, chainId)
+}
+
+// GetBroadcasts0 is a free data retrieval call binding the contract method 0xf7afe919.
+//
+// Solidity: function getBroadcasts(string contractName, uint64 chainId, uint8 txType) view returns((bytes32,uint8,address,uint64,bool)[])
+func (_Vm *VmCaller) GetBroadcasts0(opts *bind.CallOpts, contractName string, chainId uint64, txType uint8) ([]VmSafeBroadcastTxSummary, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getBroadcasts0", contractName, chainId, txType)
+
+	if err != nil {
+		return *new([]VmSafeBroadcastTxSummary), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]VmSafeBroadcastTxSummary)).(*[]VmSafeBroadcastTxSummary)
+
+	return out0, err
+
+}
+
+// GetBroadcasts0 is a free data retrieval call binding the contract method 0xf7afe919.
+//
+// Solidity: function getBroadcasts(string contractName, uint64 chainId, uint8 txType) view returns((bytes32,uint8,address,uint64,bool)[])
+func (_Vm *VmSession) GetBroadcasts0(contractName string, chainId uint64, txType uint8) ([]VmSafeBroadcastTxSummary, error) {
+	return _Vm.Contract.GetBroadcasts0(&_Vm.CallOpts, contractName, chainId, txType)
+}
+
+// GetBroadcasts0 is a free data retrieval call binding the contract method 0xf7afe919.
+//
+// Solidity: function getBroadcasts(string contractName, uint64 chainId, uint8 txType) view returns((bytes32,uint8,address,uint64,bool)[])
+func (_Vm *VmCallerSession) GetBroadcasts0(contractName string, chainId uint64, txType uint8) ([]VmSafeBroadcastTxSummary, error) {
+	return _Vm.Contract.GetBroadcasts0(&_Vm.CallOpts, contractName, chainId, txType)
+}
+
+// GetCode is a free data retrieval call binding the contract method 0x8d1cc925.
+//
+// Solidity: function getCode(string artifactPath) view returns(bytes creationBytecode)
+func (_Vm *VmCaller) GetCode(opts *bind.CallOpts, artifactPath string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getCode", artifactPath)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// GetCode is a free data retrieval call binding the contract method 0x8d1cc925.
+//
+// Solidity: function getCode(string artifactPath) view returns(bytes creationBytecode)
+func (_Vm *VmSession) GetCode(artifactPath string) ([]byte, error) {
+	return _Vm.Contract.GetCode(&_Vm.CallOpts, artifactPath)
+}
+
+// GetCode is a free data retrieval call binding the contract method 0x8d1cc925.
+//
+// Solidity: function getCode(string artifactPath) view returns(bytes creationBytecode)
+func (_Vm *VmCallerSession) GetCode(artifactPath string) ([]byte, error) {
+	return _Vm.Contract.GetCode(&_Vm.CallOpts, artifactPath)
+}
+
+// GetDeployedCode is a free data retrieval call binding the contract method 0x3ebf73b4.
+//
+// Solidity: function getDeployedCode(string artifactPath) view returns(bytes runtimeBytecode)
+func (_Vm *VmCaller) GetDeployedCode(opts *bind.CallOpts, artifactPath string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getDeployedCode", artifactPath)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// GetDeployedCode is a free data retrieval call binding the contract method 0x3ebf73b4.
+//
+// Solidity: function getDeployedCode(string artifactPath) view returns(bytes runtimeBytecode)
+func (_Vm *VmSession) GetDeployedCode(artifactPath string) ([]byte, error) {
+	return _Vm.Contract.GetDeployedCode(&_Vm.CallOpts, artifactPath)
+}
+
+// GetDeployedCode is a free data retrieval call binding the contract method 0x3ebf73b4.
+//
+// Solidity: function getDeployedCode(string artifactPath) view returns(bytes runtimeBytecode)
+func (_Vm *VmCallerSession) GetDeployedCode(artifactPath string) ([]byte, error) {
+	return _Vm.Contract.GetDeployedCode(&_Vm.CallOpts, artifactPath)
+}
+
+// GetDeployment is a free data retrieval call binding the contract method 0x0debd5d6.
+//
+// Solidity: function getDeployment(string contractName, uint64 chainId) view returns(address deployedAddress)
+func (_Vm *VmCaller) GetDeployment(opts *bind.CallOpts, contractName string, chainId uint64) (common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getDeployment", contractName, chainId)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// GetDeployment is a free data retrieval call binding the contract method 0x0debd5d6.
+//
+// Solidity: function getDeployment(string contractName, uint64 chainId) view returns(address deployedAddress)
+func (_Vm *VmSession) GetDeployment(contractName string, chainId uint64) (common.Address, error) {
+	return _Vm.Contract.GetDeployment(&_Vm.CallOpts, contractName, chainId)
+}
+
+// GetDeployment is a free data retrieval call binding the contract method 0x0debd5d6.
+//
+// Solidity: function getDeployment(string contractName, uint64 chainId) view returns(address deployedAddress)
+func (_Vm *VmCallerSession) GetDeployment(contractName string, chainId uint64) (common.Address, error) {
+	return _Vm.Contract.GetDeployment(&_Vm.CallOpts, contractName, chainId)
+}
+
+// GetDeployment0 is a free data retrieval call binding the contract method 0xa8091d97.
+//
+// Solidity: function getDeployment(string contractName) view returns(address deployedAddress)
+func (_Vm *VmCaller) GetDeployment0(opts *bind.CallOpts, contractName string) (common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getDeployment0", contractName)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// GetDeployment0 is a free data retrieval call binding the contract method 0xa8091d97.
+//
+// Solidity: function getDeployment(string contractName) view returns(address deployedAddress)
+func (_Vm *VmSession) GetDeployment0(contractName string) (common.Address, error) {
+	return _Vm.Contract.GetDeployment0(&_Vm.CallOpts, contractName)
+}
+
+// GetDeployment0 is a free data retrieval call binding the contract method 0xa8091d97.
+//
+// Solidity: function getDeployment(string contractName) view returns(address deployedAddress)
+func (_Vm *VmCallerSession) GetDeployment0(contractName string) (common.Address, error) {
+	return _Vm.Contract.GetDeployment0(&_Vm.CallOpts, contractName)
+}
+
+// GetDeployments is a free data retrieval call binding the contract method 0x74e133dd.
+//
+// Solidity: function getDeployments(string contractName, uint64 chainId) view returns(address[] deployedAddresses)
+func (_Vm *VmCaller) GetDeployments(opts *bind.CallOpts, contractName string, chainId uint64) ([]common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getDeployments", contractName, chainId)
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// GetDeployments is a free data retrieval call binding the contract method 0x74e133dd.
+//
+// Solidity: function getDeployments(string contractName, uint64 chainId) view returns(address[] deployedAddresses)
+func (_Vm *VmSession) GetDeployments(contractName string, chainId uint64) ([]common.Address, error) {
+	return _Vm.Contract.GetDeployments(&_Vm.CallOpts, contractName, chainId)
+}
+
+// GetDeployments is a free data retrieval call binding the contract method 0x74e133dd.
+//
+// Solidity: function getDeployments(string contractName, uint64 chainId) view returns(address[] deployedAddresses)
+func (_Vm *VmCallerSession) GetDeployments(contractName string, chainId uint64) ([]common.Address, error) {
+	return _Vm.Contract.GetDeployments(&_Vm.CallOpts, contractName, chainId)
+}
+
+// GetFoundryVersion is a free data retrieval call binding the contract method 0xea991bb5.
+//
+// Solidity: function getFoundryVersion() view returns(string version)
+func (_Vm *VmCaller) GetFoundryVersion(opts *bind.CallOpts) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getFoundryVersion")
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetFoundryVersion is a free data retrieval call binding the contract method 0xea991bb5.
+//
+// Solidity: function getFoundryVersion() view returns(string version)
+func (_Vm *VmSession) GetFoundryVersion() (string, error) {
+	return _Vm.Contract.GetFoundryVersion(&_Vm.CallOpts)
+}
+
+// GetFoundryVersion is a free data retrieval call binding the contract method 0xea991bb5.
+//
+// Solidity: function getFoundryVersion() view returns(string version)
+func (_Vm *VmCallerSession) GetFoundryVersion() (string, error) {
+	return _Vm.Contract.GetFoundryVersion(&_Vm.CallOpts)
+}
+
+// GetLabel is a free data retrieval call binding the contract method 0x28a249b0.
+//
+// Solidity: function getLabel(address account) view returns(string currentLabel)
+func (_Vm *VmCaller) GetLabel(opts *bind.CallOpts, account common.Address) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getLabel", account)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetLabel is a free data retrieval call binding the contract method 0x28a249b0.
+//
+// Solidity: function getLabel(address account) view returns(string currentLabel)
+func (_Vm *VmSession) GetLabel(account common.Address) (string, error) {
+	return _Vm.Contract.GetLabel(&_Vm.CallOpts, account)
+}
+
+// GetLabel is a free data retrieval call binding the contract method 0x28a249b0.
+//
+// Solidity: function getLabel(address account) view returns(string currentLabel)
+func (_Vm *VmCallerSession) GetLabel(account common.Address) (string, error) {
+	return _Vm.Contract.GetLabel(&_Vm.CallOpts, account)
+}
+
+// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab.
+//
+// Solidity: function getNonce(address account) view returns(uint64 nonce)
+func (_Vm *VmCaller) GetNonce(opts *bind.CallOpts, account common.Address) (uint64, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getNonce", account)
+
+	if err != nil {
+		return *new(uint64), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64)
+
+	return out0, err
+
+}
+
+// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab.
+//
+// Solidity: function getNonce(address account) view returns(uint64 nonce)
+func (_Vm *VmSession) GetNonce(account common.Address) (uint64, error) {
+	return _Vm.Contract.GetNonce(&_Vm.CallOpts, account)
+}
+
+// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab.
+//
+// Solidity: function getNonce(address account) view returns(uint64 nonce)
+func (_Vm *VmCallerSession) GetNonce(account common.Address) (uint64, error) {
+	return _Vm.Contract.GetNonce(&_Vm.CallOpts, account)
+}
+
+// GetStateDiff is a free data retrieval call binding the contract method 0x80df01cc.
+//
+// Solidity: function getStateDiff() view returns(string diff)
+func (_Vm *VmCaller) GetStateDiff(opts *bind.CallOpts) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getStateDiff")
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetStateDiff is a free data retrieval call binding the contract method 0x80df01cc.
+//
+// Solidity: function getStateDiff() view returns(string diff)
+func (_Vm *VmSession) GetStateDiff() (string, error) {
+	return _Vm.Contract.GetStateDiff(&_Vm.CallOpts)
+}
+
+// GetStateDiff is a free data retrieval call binding the contract method 0x80df01cc.
+//
+// Solidity: function getStateDiff() view returns(string diff)
+func (_Vm *VmCallerSession) GetStateDiff() (string, error) {
+	return _Vm.Contract.GetStateDiff(&_Vm.CallOpts)
+}
+
+// GetStateDiffJson is a free data retrieval call binding the contract method 0xf54fe009.
+//
+// Solidity: function getStateDiffJson() view returns(string diff)
+func (_Vm *VmCaller) GetStateDiffJson(opts *bind.CallOpts) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "getStateDiffJson")
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetStateDiffJson is a free data retrieval call binding the contract method 0xf54fe009.
+//
+// Solidity: function getStateDiffJson() view returns(string diff)
+func (_Vm *VmSession) GetStateDiffJson() (string, error) {
+	return _Vm.Contract.GetStateDiffJson(&_Vm.CallOpts)
+}
+
+// GetStateDiffJson is a free data retrieval call binding the contract method 0xf54fe009.
+//
+// Solidity: function getStateDiffJson() view returns(string diff)
+func (_Vm *VmCallerSession) GetStateDiffJson() (string, error) {
+	return _Vm.Contract.GetStateDiffJson(&_Vm.CallOpts)
+}
+
+// IndexOf is a free data retrieval call binding the contract method 0x8a0807b7.
+//
+// Solidity: function indexOf(string input, string key) pure returns(uint256)
+func (_Vm *VmCaller) IndexOf(opts *bind.CallOpts, input string, key string) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "indexOf", input, key)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// IndexOf is a free data retrieval call binding the contract method 0x8a0807b7.
+//
+// Solidity: function indexOf(string input, string key) pure returns(uint256)
+func (_Vm *VmSession) IndexOf(input string, key string) (*big.Int, error) {
+	return _Vm.Contract.IndexOf(&_Vm.CallOpts, input, key)
+}
+
+// IndexOf is a free data retrieval call binding the contract method 0x8a0807b7.
+//
+// Solidity: function indexOf(string input, string key) pure returns(uint256)
+func (_Vm *VmCallerSession) IndexOf(input string, key string) (*big.Int, error) {
+	return _Vm.Contract.IndexOf(&_Vm.CallOpts, input, key)
+}
+
+// IsContext is a free data retrieval call binding the contract method 0x64af255d.
+//
+// Solidity: function isContext(uint8 context) view returns(bool result)
+func (_Vm *VmCaller) IsContext(opts *bind.CallOpts, context uint8) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "isContext", context)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// IsContext is a free data retrieval call binding the contract method 0x64af255d.
+//
+// Solidity: function isContext(uint8 context) view returns(bool result)
+func (_Vm *VmSession) IsContext(context uint8) (bool, error) {
+	return _Vm.Contract.IsContext(&_Vm.CallOpts, context)
+}
+
+// IsContext is a free data retrieval call binding the contract method 0x64af255d.
+//
+// Solidity: function isContext(uint8 context) view returns(bool result)
+func (_Vm *VmCallerSession) IsContext(context uint8) (bool, error) {
+	return _Vm.Contract.IsContext(&_Vm.CallOpts, context)
+}
+
+// IsDir is a free data retrieval call binding the contract method 0x7d15d019.
+//
+// Solidity: function isDir(string path) view returns(bool result)
+func (_Vm *VmCaller) IsDir(opts *bind.CallOpts, path string) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "isDir", path)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// IsDir is a free data retrieval call binding the contract method 0x7d15d019.
+//
+// Solidity: function isDir(string path) view returns(bool result)
+func (_Vm *VmSession) IsDir(path string) (bool, error) {
+	return _Vm.Contract.IsDir(&_Vm.CallOpts, path)
+}
+
+// IsDir is a free data retrieval call binding the contract method 0x7d15d019.
+//
+// Solidity: function isDir(string path) view returns(bool result)
+func (_Vm *VmCallerSession) IsDir(path string) (bool, error) {
+	return _Vm.Contract.IsDir(&_Vm.CallOpts, path)
+}
+
+// IsFile is a free data retrieval call binding the contract method 0xe0eb04d4.
+//
+// Solidity: function isFile(string path) view returns(bool result)
+func (_Vm *VmCaller) IsFile(opts *bind.CallOpts, path string) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "isFile", path)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// IsFile is a free data retrieval call binding the contract method 0xe0eb04d4.
+//
+// Solidity: function isFile(string path) view returns(bool result)
+func (_Vm *VmSession) IsFile(path string) (bool, error) {
+	return _Vm.Contract.IsFile(&_Vm.CallOpts, path)
+}
+
+// IsFile is a free data retrieval call binding the contract method 0xe0eb04d4.
+//
+// Solidity: function isFile(string path) view returns(bool result)
+func (_Vm *VmCallerSession) IsFile(path string) (bool, error) {
+	return _Vm.Contract.IsFile(&_Vm.CallOpts, path)
+}
+
+// IsPersistent is a free data retrieval call binding the contract method 0xd92d8efd.
+//
+// Solidity: function isPersistent(address account) view returns(bool persistent)
+func (_Vm *VmCaller) IsPersistent(opts *bind.CallOpts, account common.Address) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "isPersistent", account)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// IsPersistent is a free data retrieval call binding the contract method 0xd92d8efd.
+//
+// Solidity: function isPersistent(address account) view returns(bool persistent)
+func (_Vm *VmSession) IsPersistent(account common.Address) (bool, error) {
+	return _Vm.Contract.IsPersistent(&_Vm.CallOpts, account)
+}
+
+// IsPersistent is a free data retrieval call binding the contract method 0xd92d8efd.
+//
+// Solidity: function isPersistent(address account) view returns(bool persistent)
+func (_Vm *VmCallerSession) IsPersistent(account common.Address) (bool, error) {
+	return _Vm.Contract.IsPersistent(&_Vm.CallOpts, account)
+}
+
+// KeyExists is a free data retrieval call binding the contract method 0x528a683c.
+//
+// Solidity: function keyExists(string json, string key) view returns(bool)
+func (_Vm *VmCaller) KeyExists(opts *bind.CallOpts, json string, key string) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "keyExists", json, key)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// KeyExists is a free data retrieval call binding the contract method 0x528a683c.
+//
+// Solidity: function keyExists(string json, string key) view returns(bool)
+func (_Vm *VmSession) KeyExists(json string, key string) (bool, error) {
+	return _Vm.Contract.KeyExists(&_Vm.CallOpts, json, key)
+}
+
+// KeyExists is a free data retrieval call binding the contract method 0x528a683c.
+//
+// Solidity: function keyExists(string json, string key) view returns(bool)
+func (_Vm *VmCallerSession) KeyExists(json string, key string) (bool, error) {
+	return _Vm.Contract.KeyExists(&_Vm.CallOpts, json, key)
+}
+
+// KeyExistsJson is a free data retrieval call binding the contract method 0xdb4235f6.
+//
+// Solidity: function keyExistsJson(string json, string key) view returns(bool)
+func (_Vm *VmCaller) KeyExistsJson(opts *bind.CallOpts, json string, key string) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "keyExistsJson", json, key)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// KeyExistsJson is a free data retrieval call binding the contract method 0xdb4235f6.
+//
+// Solidity: function keyExistsJson(string json, string key) view returns(bool)
+func (_Vm *VmSession) KeyExistsJson(json string, key string) (bool, error) {
+	return _Vm.Contract.KeyExistsJson(&_Vm.CallOpts, json, key)
+}
+
+// KeyExistsJson is a free data retrieval call binding the contract method 0xdb4235f6.
+//
+// Solidity: function keyExistsJson(string json, string key) view returns(bool)
+func (_Vm *VmCallerSession) KeyExistsJson(json string, key string) (bool, error) {
+	return _Vm.Contract.KeyExistsJson(&_Vm.CallOpts, json, key)
+}
+
+// KeyExistsToml is a free data retrieval call binding the contract method 0x600903ad.
+//
+// Solidity: function keyExistsToml(string toml, string key) view returns(bool)
+func (_Vm *VmCaller) KeyExistsToml(opts *bind.CallOpts, toml string, key string) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "keyExistsToml", toml, key)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// KeyExistsToml is a free data retrieval call binding the contract method 0x600903ad.
+//
+// Solidity: function keyExistsToml(string toml, string key) view returns(bool)
+func (_Vm *VmSession) KeyExistsToml(toml string, key string) (bool, error) {
+	return _Vm.Contract.KeyExistsToml(&_Vm.CallOpts, toml, key)
+}
+
+// KeyExistsToml is a free data retrieval call binding the contract method 0x600903ad.
+//
+// Solidity: function keyExistsToml(string toml, string key) view returns(bool)
+func (_Vm *VmCallerSession) KeyExistsToml(toml string, key string) (bool, error) {
+	return _Vm.Contract.KeyExistsToml(&_Vm.CallOpts, toml, key)
+}
+
+// LastCallGas is a free data retrieval call binding the contract method 0x2b589b28.
+//
+// Solidity: function lastCallGas() view returns((uint64,uint64,uint64,int64,uint64) gas)
+func (_Vm *VmCaller) LastCallGas(opts *bind.CallOpts) (VmSafeGas, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "lastCallGas")
+
+	if err != nil {
+		return *new(VmSafeGas), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(VmSafeGas)).(*VmSafeGas)
+
+	return out0, err
+
+}
+
+// LastCallGas is a free data retrieval call binding the contract method 0x2b589b28.
+//
+// Solidity: function lastCallGas() view returns((uint64,uint64,uint64,int64,uint64) gas)
+func (_Vm *VmSession) LastCallGas() (VmSafeGas, error) {
+	return _Vm.Contract.LastCallGas(&_Vm.CallOpts)
+}
+
+// LastCallGas is a free data retrieval call binding the contract method 0x2b589b28.
+//
+// Solidity: function lastCallGas() view returns((uint64,uint64,uint64,int64,uint64) gas)
+func (_Vm *VmCallerSession) LastCallGas() (VmSafeGas, error) {
+	return _Vm.Contract.LastCallGas(&_Vm.CallOpts)
+}
+
+// Load is a free data retrieval call binding the contract method 0x667f9d70.
+//
+// Solidity: function load(address target, bytes32 slot) view returns(bytes32 data)
+func (_Vm *VmCaller) Load(opts *bind.CallOpts, target common.Address, slot [32]byte) ([32]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "load", target, slot)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// Load is a free data retrieval call binding the contract method 0x667f9d70.
+//
+// Solidity: function load(address target, bytes32 slot) view returns(bytes32 data)
+func (_Vm *VmSession) Load(target common.Address, slot [32]byte) ([32]byte, error) {
+	return _Vm.Contract.Load(&_Vm.CallOpts, target, slot)
+}
+
+// Load is a free data retrieval call binding the contract method 0x667f9d70.
+//
+// Solidity: function load(address target, bytes32 slot) view returns(bytes32 data)
+func (_Vm *VmCallerSession) Load(target common.Address, slot [32]byte) ([32]byte, error) {
+	return _Vm.Contract.Load(&_Vm.CallOpts, target, slot)
+}
+
+// ParseAddress is a free data retrieval call binding the contract method 0xc6ce059d.
+//
+// Solidity: function parseAddress(string stringifiedValue) pure returns(address parsedValue)
+func (_Vm *VmCaller) ParseAddress(opts *bind.CallOpts, stringifiedValue string) (common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseAddress", stringifiedValue)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// ParseAddress is a free data retrieval call binding the contract method 0xc6ce059d.
+//
+// Solidity: function parseAddress(string stringifiedValue) pure returns(address parsedValue)
+func (_Vm *VmSession) ParseAddress(stringifiedValue string) (common.Address, error) {
+	return _Vm.Contract.ParseAddress(&_Vm.CallOpts, stringifiedValue)
+}
+
+// ParseAddress is a free data retrieval call binding the contract method 0xc6ce059d.
+//
+// Solidity: function parseAddress(string stringifiedValue) pure returns(address parsedValue)
+func (_Vm *VmCallerSession) ParseAddress(stringifiedValue string) (common.Address, error) {
+	return _Vm.Contract.ParseAddress(&_Vm.CallOpts, stringifiedValue)
+}
+
+// ParseBool is a free data retrieval call binding the contract method 0x974ef924.
+//
+// Solidity: function parseBool(string stringifiedValue) pure returns(bool parsedValue)
+func (_Vm *VmCaller) ParseBool(opts *bind.CallOpts, stringifiedValue string) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseBool", stringifiedValue)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// ParseBool is a free data retrieval call binding the contract method 0x974ef924.
+//
+// Solidity: function parseBool(string stringifiedValue) pure returns(bool parsedValue)
+func (_Vm *VmSession) ParseBool(stringifiedValue string) (bool, error) {
+	return _Vm.Contract.ParseBool(&_Vm.CallOpts, stringifiedValue)
+}
+
+// ParseBool is a free data retrieval call binding the contract method 0x974ef924.
+//
+// Solidity: function parseBool(string stringifiedValue) pure returns(bool parsedValue)
+func (_Vm *VmCallerSession) ParseBool(stringifiedValue string) (bool, error) {
+	return _Vm.Contract.ParseBool(&_Vm.CallOpts, stringifiedValue)
+}
+
+// ParseBytes is a free data retrieval call binding the contract method 0x8f5d232d.
+//
+// Solidity: function parseBytes(string stringifiedValue) pure returns(bytes parsedValue)
+func (_Vm *VmCaller) ParseBytes(opts *bind.CallOpts, stringifiedValue string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseBytes", stringifiedValue)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseBytes is a free data retrieval call binding the contract method 0x8f5d232d.
+//
+// Solidity: function parseBytes(string stringifiedValue) pure returns(bytes parsedValue)
+func (_Vm *VmSession) ParseBytes(stringifiedValue string) ([]byte, error) {
+	return _Vm.Contract.ParseBytes(&_Vm.CallOpts, stringifiedValue)
+}
+
+// ParseBytes is a free data retrieval call binding the contract method 0x8f5d232d.
+//
+// Solidity: function parseBytes(string stringifiedValue) pure returns(bytes parsedValue)
+func (_Vm *VmCallerSession) ParseBytes(stringifiedValue string) ([]byte, error) {
+	return _Vm.Contract.ParseBytes(&_Vm.CallOpts, stringifiedValue)
+}
+
+// ParseBytes32 is a free data retrieval call binding the contract method 0x087e6e81.
+//
+// Solidity: function parseBytes32(string stringifiedValue) pure returns(bytes32 parsedValue)
+func (_Vm *VmCaller) ParseBytes32(opts *bind.CallOpts, stringifiedValue string) ([32]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseBytes32", stringifiedValue)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// ParseBytes32 is a free data retrieval call binding the contract method 0x087e6e81.
+//
+// Solidity: function parseBytes32(string stringifiedValue) pure returns(bytes32 parsedValue)
+func (_Vm *VmSession) ParseBytes32(stringifiedValue string) ([32]byte, error) {
+	return _Vm.Contract.ParseBytes32(&_Vm.CallOpts, stringifiedValue)
+}
+
+// ParseBytes32 is a free data retrieval call binding the contract method 0x087e6e81.
+//
+// Solidity: function parseBytes32(string stringifiedValue) pure returns(bytes32 parsedValue)
+func (_Vm *VmCallerSession) ParseBytes32(stringifiedValue string) ([32]byte, error) {
+	return _Vm.Contract.ParseBytes32(&_Vm.CallOpts, stringifiedValue)
+}
+
+// ParseInt is a free data retrieval call binding the contract method 0x42346c5e.
+//
+// Solidity: function parseInt(string stringifiedValue) pure returns(int256 parsedValue)
+func (_Vm *VmCaller) ParseInt(opts *bind.CallOpts, stringifiedValue string) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseInt", stringifiedValue)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ParseInt is a free data retrieval call binding the contract method 0x42346c5e.
+//
+// Solidity: function parseInt(string stringifiedValue) pure returns(int256 parsedValue)
+func (_Vm *VmSession) ParseInt(stringifiedValue string) (*big.Int, error) {
+	return _Vm.Contract.ParseInt(&_Vm.CallOpts, stringifiedValue)
+}
+
+// ParseInt is a free data retrieval call binding the contract method 0x42346c5e.
+//
+// Solidity: function parseInt(string stringifiedValue) pure returns(int256 parsedValue)
+func (_Vm *VmCallerSession) ParseInt(stringifiedValue string) (*big.Int, error) {
+	return _Vm.Contract.ParseInt(&_Vm.CallOpts, stringifiedValue)
+}
+
+// ParseJson is a free data retrieval call binding the contract method 0x6a82600a.
+//
+// Solidity: function parseJson(string json) pure returns(bytes abiEncodedData)
+func (_Vm *VmCaller) ParseJson(opts *bind.CallOpts, json string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJson", json)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseJson is a free data retrieval call binding the contract method 0x6a82600a.
+//
+// Solidity: function parseJson(string json) pure returns(bytes abiEncodedData)
+func (_Vm *VmSession) ParseJson(json string) ([]byte, error) {
+	return _Vm.Contract.ParseJson(&_Vm.CallOpts, json)
+}
+
+// ParseJson is a free data retrieval call binding the contract method 0x6a82600a.
+//
+// Solidity: function parseJson(string json) pure returns(bytes abiEncodedData)
+func (_Vm *VmCallerSession) ParseJson(json string) ([]byte, error) {
+	return _Vm.Contract.ParseJson(&_Vm.CallOpts, json)
+}
+
+// ParseJson0 is a free data retrieval call binding the contract method 0x85940ef1.
+//
+// Solidity: function parseJson(string json, string key) pure returns(bytes abiEncodedData)
+func (_Vm *VmCaller) ParseJson0(opts *bind.CallOpts, json string, key string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJson0", json, key)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseJson0 is a free data retrieval call binding the contract method 0x85940ef1.
+//
+// Solidity: function parseJson(string json, string key) pure returns(bytes abiEncodedData)
+func (_Vm *VmSession) ParseJson0(json string, key string) ([]byte, error) {
+	return _Vm.Contract.ParseJson0(&_Vm.CallOpts, json, key)
+}
+
+// ParseJson0 is a free data retrieval call binding the contract method 0x85940ef1.
+//
+// Solidity: function parseJson(string json, string key) pure returns(bytes abiEncodedData)
+func (_Vm *VmCallerSession) ParseJson0(json string, key string) ([]byte, error) {
+	return _Vm.Contract.ParseJson0(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonAddress is a free data retrieval call binding the contract method 0x1e19e657.
+//
+// Solidity: function parseJsonAddress(string json, string key) pure returns(address)
+func (_Vm *VmCaller) ParseJsonAddress(opts *bind.CallOpts, json string, key string) (common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonAddress", json, key)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// ParseJsonAddress is a free data retrieval call binding the contract method 0x1e19e657.
+//
+// Solidity: function parseJsonAddress(string json, string key) pure returns(address)
+func (_Vm *VmSession) ParseJsonAddress(json string, key string) (common.Address, error) {
+	return _Vm.Contract.ParseJsonAddress(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonAddress is a free data retrieval call binding the contract method 0x1e19e657.
+//
+// Solidity: function parseJsonAddress(string json, string key) pure returns(address)
+func (_Vm *VmCallerSession) ParseJsonAddress(json string, key string) (common.Address, error) {
+	return _Vm.Contract.ParseJsonAddress(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonAddressArray is a free data retrieval call binding the contract method 0x2fce7883.
+//
+// Solidity: function parseJsonAddressArray(string json, string key) pure returns(address[])
+func (_Vm *VmCaller) ParseJsonAddressArray(opts *bind.CallOpts, json string, key string) ([]common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonAddressArray", json, key)
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ParseJsonAddressArray is a free data retrieval call binding the contract method 0x2fce7883.
+//
+// Solidity: function parseJsonAddressArray(string json, string key) pure returns(address[])
+func (_Vm *VmSession) ParseJsonAddressArray(json string, key string) ([]common.Address, error) {
+	return _Vm.Contract.ParseJsonAddressArray(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonAddressArray is a free data retrieval call binding the contract method 0x2fce7883.
+//
+// Solidity: function parseJsonAddressArray(string json, string key) pure returns(address[])
+func (_Vm *VmCallerSession) ParseJsonAddressArray(json string, key string) ([]common.Address, error) {
+	return _Vm.Contract.ParseJsonAddressArray(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonBool is a free data retrieval call binding the contract method 0x9f86dc91.
+//
+// Solidity: function parseJsonBool(string json, string key) pure returns(bool)
+func (_Vm *VmCaller) ParseJsonBool(opts *bind.CallOpts, json string, key string) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonBool", json, key)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// ParseJsonBool is a free data retrieval call binding the contract method 0x9f86dc91.
+//
+// Solidity: function parseJsonBool(string json, string key) pure returns(bool)
+func (_Vm *VmSession) ParseJsonBool(json string, key string) (bool, error) {
+	return _Vm.Contract.ParseJsonBool(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonBool is a free data retrieval call binding the contract method 0x9f86dc91.
+//
+// Solidity: function parseJsonBool(string json, string key) pure returns(bool)
+func (_Vm *VmCallerSession) ParseJsonBool(json string, key string) (bool, error) {
+	return _Vm.Contract.ParseJsonBool(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonBoolArray is a free data retrieval call binding the contract method 0x91f3b94f.
+//
+// Solidity: function parseJsonBoolArray(string json, string key) pure returns(bool[])
+func (_Vm *VmCaller) ParseJsonBoolArray(opts *bind.CallOpts, json string, key string) ([]bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonBoolArray", json, key)
+
+	if err != nil {
+		return *new([]bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool)
+
+	return out0, err
+
+}
+
+// ParseJsonBoolArray is a free data retrieval call binding the contract method 0x91f3b94f.
+//
+// Solidity: function parseJsonBoolArray(string json, string key) pure returns(bool[])
+func (_Vm *VmSession) ParseJsonBoolArray(json string, key string) ([]bool, error) {
+	return _Vm.Contract.ParseJsonBoolArray(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonBoolArray is a free data retrieval call binding the contract method 0x91f3b94f.
+//
+// Solidity: function parseJsonBoolArray(string json, string key) pure returns(bool[])
+func (_Vm *VmCallerSession) ParseJsonBoolArray(json string, key string) ([]bool, error) {
+	return _Vm.Contract.ParseJsonBoolArray(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonBytes is a free data retrieval call binding the contract method 0xfd921be8.
+//
+// Solidity: function parseJsonBytes(string json, string key) pure returns(bytes)
+func (_Vm *VmCaller) ParseJsonBytes(opts *bind.CallOpts, json string, key string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonBytes", json, key)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonBytes is a free data retrieval call binding the contract method 0xfd921be8.
+//
+// Solidity: function parseJsonBytes(string json, string key) pure returns(bytes)
+func (_Vm *VmSession) ParseJsonBytes(json string, key string) ([]byte, error) {
+	return _Vm.Contract.ParseJsonBytes(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonBytes is a free data retrieval call binding the contract method 0xfd921be8.
+//
+// Solidity: function parseJsonBytes(string json, string key) pure returns(bytes)
+func (_Vm *VmCallerSession) ParseJsonBytes(json string, key string) ([]byte, error) {
+	return _Vm.Contract.ParseJsonBytes(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonBytes32 is a free data retrieval call binding the contract method 0x1777e59d.
+//
+// Solidity: function parseJsonBytes32(string json, string key) pure returns(bytes32)
+func (_Vm *VmCaller) ParseJsonBytes32(opts *bind.CallOpts, json string, key string) ([32]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonBytes32", json, key)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonBytes32 is a free data retrieval call binding the contract method 0x1777e59d.
+//
+// Solidity: function parseJsonBytes32(string json, string key) pure returns(bytes32)
+func (_Vm *VmSession) ParseJsonBytes32(json string, key string) ([32]byte, error) {
+	return _Vm.Contract.ParseJsonBytes32(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonBytes32 is a free data retrieval call binding the contract method 0x1777e59d.
+//
+// Solidity: function parseJsonBytes32(string json, string key) pure returns(bytes32)
+func (_Vm *VmCallerSession) ParseJsonBytes32(json string, key string) ([32]byte, error) {
+	return _Vm.Contract.ParseJsonBytes32(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonBytes32Array is a free data retrieval call binding the contract method 0x91c75bc3.
+//
+// Solidity: function parseJsonBytes32Array(string json, string key) pure returns(bytes32[])
+func (_Vm *VmCaller) ParseJsonBytes32Array(opts *bind.CallOpts, json string, key string) ([][32]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonBytes32Array", json, key)
+
+	if err != nil {
+		return *new([][32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonBytes32Array is a free data retrieval call binding the contract method 0x91c75bc3.
+//
+// Solidity: function parseJsonBytes32Array(string json, string key) pure returns(bytes32[])
+func (_Vm *VmSession) ParseJsonBytes32Array(json string, key string) ([][32]byte, error) {
+	return _Vm.Contract.ParseJsonBytes32Array(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonBytes32Array is a free data retrieval call binding the contract method 0x91c75bc3.
+//
+// Solidity: function parseJsonBytes32Array(string json, string key) pure returns(bytes32[])
+func (_Vm *VmCallerSession) ParseJsonBytes32Array(json string, key string) ([][32]byte, error) {
+	return _Vm.Contract.ParseJsonBytes32Array(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonBytesArray is a free data retrieval call binding the contract method 0x6631aa99.
+//
+// Solidity: function parseJsonBytesArray(string json, string key) pure returns(bytes[])
+func (_Vm *VmCaller) ParseJsonBytesArray(opts *bind.CallOpts, json string, key string) ([][]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonBytesArray", json, key)
+
+	if err != nil {
+		return *new([][]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonBytesArray is a free data retrieval call binding the contract method 0x6631aa99.
+//
+// Solidity: function parseJsonBytesArray(string json, string key) pure returns(bytes[])
+func (_Vm *VmSession) ParseJsonBytesArray(json string, key string) ([][]byte, error) {
+	return _Vm.Contract.ParseJsonBytesArray(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonBytesArray is a free data retrieval call binding the contract method 0x6631aa99.
+//
+// Solidity: function parseJsonBytesArray(string json, string key) pure returns(bytes[])
+func (_Vm *VmCallerSession) ParseJsonBytesArray(json string, key string) ([][]byte, error) {
+	return _Vm.Contract.ParseJsonBytesArray(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonInt is a free data retrieval call binding the contract method 0x7b048ccd.
+//
+// Solidity: function parseJsonInt(string json, string key) pure returns(int256)
+func (_Vm *VmCaller) ParseJsonInt(opts *bind.CallOpts, json string, key string) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonInt", json, key)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ParseJsonInt is a free data retrieval call binding the contract method 0x7b048ccd.
+//
+// Solidity: function parseJsonInt(string json, string key) pure returns(int256)
+func (_Vm *VmSession) ParseJsonInt(json string, key string) (*big.Int, error) {
+	return _Vm.Contract.ParseJsonInt(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonInt is a free data retrieval call binding the contract method 0x7b048ccd.
+//
+// Solidity: function parseJsonInt(string json, string key) pure returns(int256)
+func (_Vm *VmCallerSession) ParseJsonInt(json string, key string) (*big.Int, error) {
+	return _Vm.Contract.ParseJsonInt(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonIntArray is a free data retrieval call binding the contract method 0x9983c28a.
+//
+// Solidity: function parseJsonIntArray(string json, string key) pure returns(int256[])
+func (_Vm *VmCaller) ParseJsonIntArray(opts *bind.CallOpts, json string, key string) ([]*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonIntArray", json, key)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// ParseJsonIntArray is a free data retrieval call binding the contract method 0x9983c28a.
+//
+// Solidity: function parseJsonIntArray(string json, string key) pure returns(int256[])
+func (_Vm *VmSession) ParseJsonIntArray(json string, key string) ([]*big.Int, error) {
+	return _Vm.Contract.ParseJsonIntArray(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonIntArray is a free data retrieval call binding the contract method 0x9983c28a.
+//
+// Solidity: function parseJsonIntArray(string json, string key) pure returns(int256[])
+func (_Vm *VmCallerSession) ParseJsonIntArray(json string, key string) ([]*big.Int, error) {
+	return _Vm.Contract.ParseJsonIntArray(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonKeys is a free data retrieval call binding the contract method 0x213e4198.
+//
+// Solidity: function parseJsonKeys(string json, string key) pure returns(string[] keys)
+func (_Vm *VmCaller) ParseJsonKeys(opts *bind.CallOpts, json string, key string) ([]string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonKeys", json, key)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ParseJsonKeys is a free data retrieval call binding the contract method 0x213e4198.
+//
+// Solidity: function parseJsonKeys(string json, string key) pure returns(string[] keys)
+func (_Vm *VmSession) ParseJsonKeys(json string, key string) ([]string, error) {
+	return _Vm.Contract.ParseJsonKeys(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonKeys is a free data retrieval call binding the contract method 0x213e4198.
+//
+// Solidity: function parseJsonKeys(string json, string key) pure returns(string[] keys)
+func (_Vm *VmCallerSession) ParseJsonKeys(json string, key string) ([]string, error) {
+	return _Vm.Contract.ParseJsonKeys(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonString is a free data retrieval call binding the contract method 0x49c4fac8.
+//
+// Solidity: function parseJsonString(string json, string key) pure returns(string)
+func (_Vm *VmCaller) ParseJsonString(opts *bind.CallOpts, json string, key string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonString", json, key)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ParseJsonString is a free data retrieval call binding the contract method 0x49c4fac8.
+//
+// Solidity: function parseJsonString(string json, string key) pure returns(string)
+func (_Vm *VmSession) ParseJsonString(json string, key string) (string, error) {
+	return _Vm.Contract.ParseJsonString(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonString is a free data retrieval call binding the contract method 0x49c4fac8.
+//
+// Solidity: function parseJsonString(string json, string key) pure returns(string)
+func (_Vm *VmCallerSession) ParseJsonString(json string, key string) (string, error) {
+	return _Vm.Contract.ParseJsonString(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonStringArray is a free data retrieval call binding the contract method 0x498fdcf4.
+//
+// Solidity: function parseJsonStringArray(string json, string key) pure returns(string[])
+func (_Vm *VmCaller) ParseJsonStringArray(opts *bind.CallOpts, json string, key string) ([]string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonStringArray", json, key)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ParseJsonStringArray is a free data retrieval call binding the contract method 0x498fdcf4.
+//
+// Solidity: function parseJsonStringArray(string json, string key) pure returns(string[])
+func (_Vm *VmSession) ParseJsonStringArray(json string, key string) ([]string, error) {
+	return _Vm.Contract.ParseJsonStringArray(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonStringArray is a free data retrieval call binding the contract method 0x498fdcf4.
+//
+// Solidity: function parseJsonStringArray(string json, string key) pure returns(string[])
+func (_Vm *VmCallerSession) ParseJsonStringArray(json string, key string) ([]string, error) {
+	return _Vm.Contract.ParseJsonStringArray(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonType is a free data retrieval call binding the contract method 0xa9da313b.
+//
+// Solidity: function parseJsonType(string json, string typeDescription) pure returns(bytes)
+func (_Vm *VmCaller) ParseJsonType(opts *bind.CallOpts, json string, typeDescription string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonType", json, typeDescription)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonType is a free data retrieval call binding the contract method 0xa9da313b.
+//
+// Solidity: function parseJsonType(string json, string typeDescription) pure returns(bytes)
+func (_Vm *VmSession) ParseJsonType(json string, typeDescription string) ([]byte, error) {
+	return _Vm.Contract.ParseJsonType(&_Vm.CallOpts, json, typeDescription)
+}
+
+// ParseJsonType is a free data retrieval call binding the contract method 0xa9da313b.
+//
+// Solidity: function parseJsonType(string json, string typeDescription) pure returns(bytes)
+func (_Vm *VmCallerSession) ParseJsonType(json string, typeDescription string) ([]byte, error) {
+	return _Vm.Contract.ParseJsonType(&_Vm.CallOpts, json, typeDescription)
+}
+
+// ParseJsonType0 is a free data retrieval call binding the contract method 0xe3f5ae33.
+//
+// Solidity: function parseJsonType(string json, string key, string typeDescription) pure returns(bytes)
+func (_Vm *VmCaller) ParseJsonType0(opts *bind.CallOpts, json string, key string, typeDescription string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonType0", json, key, typeDescription)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonType0 is a free data retrieval call binding the contract method 0xe3f5ae33.
+//
+// Solidity: function parseJsonType(string json, string key, string typeDescription) pure returns(bytes)
+func (_Vm *VmSession) ParseJsonType0(json string, key string, typeDescription string) ([]byte, error) {
+	return _Vm.Contract.ParseJsonType0(&_Vm.CallOpts, json, key, typeDescription)
+}
+
+// ParseJsonType0 is a free data retrieval call binding the contract method 0xe3f5ae33.
+//
+// Solidity: function parseJsonType(string json, string key, string typeDescription) pure returns(bytes)
+func (_Vm *VmCallerSession) ParseJsonType0(json string, key string, typeDescription string) ([]byte, error) {
+	return _Vm.Contract.ParseJsonType0(&_Vm.CallOpts, json, key, typeDescription)
+}
+
+// ParseJsonTypeArray is a free data retrieval call binding the contract method 0x0175d535.
+//
+// Solidity: function parseJsonTypeArray(string json, string key, string typeDescription) pure returns(bytes)
+func (_Vm *VmCaller) ParseJsonTypeArray(opts *bind.CallOpts, json string, key string, typeDescription string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonTypeArray", json, key, typeDescription)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonTypeArray is a free data retrieval call binding the contract method 0x0175d535.
+//
+// Solidity: function parseJsonTypeArray(string json, string key, string typeDescription) pure returns(bytes)
+func (_Vm *VmSession) ParseJsonTypeArray(json string, key string, typeDescription string) ([]byte, error) {
+	return _Vm.Contract.ParseJsonTypeArray(&_Vm.CallOpts, json, key, typeDescription)
+}
+
+// ParseJsonTypeArray is a free data retrieval call binding the contract method 0x0175d535.
+//
+// Solidity: function parseJsonTypeArray(string json, string key, string typeDescription) pure returns(bytes)
+func (_Vm *VmCallerSession) ParseJsonTypeArray(json string, key string, typeDescription string) ([]byte, error) {
+	return _Vm.Contract.ParseJsonTypeArray(&_Vm.CallOpts, json, key, typeDescription)
+}
+
+// ParseJsonUint is a free data retrieval call binding the contract method 0xaddde2b6.
+//
+// Solidity: function parseJsonUint(string json, string key) pure returns(uint256)
+func (_Vm *VmCaller) ParseJsonUint(opts *bind.CallOpts, json string, key string) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonUint", json, key)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ParseJsonUint is a free data retrieval call binding the contract method 0xaddde2b6.
+//
+// Solidity: function parseJsonUint(string json, string key) pure returns(uint256)
+func (_Vm *VmSession) ParseJsonUint(json string, key string) (*big.Int, error) {
+	return _Vm.Contract.ParseJsonUint(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonUint is a free data retrieval call binding the contract method 0xaddde2b6.
+//
+// Solidity: function parseJsonUint(string json, string key) pure returns(uint256)
+func (_Vm *VmCallerSession) ParseJsonUint(json string, key string) (*big.Int, error) {
+	return _Vm.Contract.ParseJsonUint(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonUintArray is a free data retrieval call binding the contract method 0x522074ab.
+//
+// Solidity: function parseJsonUintArray(string json, string key) pure returns(uint256[])
+func (_Vm *VmCaller) ParseJsonUintArray(opts *bind.CallOpts, json string, key string) ([]*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseJsonUintArray", json, key)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// ParseJsonUintArray is a free data retrieval call binding the contract method 0x522074ab.
+//
+// Solidity: function parseJsonUintArray(string json, string key) pure returns(uint256[])
+func (_Vm *VmSession) ParseJsonUintArray(json string, key string) ([]*big.Int, error) {
+	return _Vm.Contract.ParseJsonUintArray(&_Vm.CallOpts, json, key)
+}
+
+// ParseJsonUintArray is a free data retrieval call binding the contract method 0x522074ab.
+//
+// Solidity: function parseJsonUintArray(string json, string key) pure returns(uint256[])
+func (_Vm *VmCallerSession) ParseJsonUintArray(json string, key string) ([]*big.Int, error) {
+	return _Vm.Contract.ParseJsonUintArray(&_Vm.CallOpts, json, key)
+}
+
+// ParseToml is a free data retrieval call binding the contract method 0x37736e08.
+//
+// Solidity: function parseToml(string toml, string key) pure returns(bytes abiEncodedData)
+func (_Vm *VmCaller) ParseToml(opts *bind.CallOpts, toml string, key string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseToml", toml, key)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseToml is a free data retrieval call binding the contract method 0x37736e08.
+//
+// Solidity: function parseToml(string toml, string key) pure returns(bytes abiEncodedData)
+func (_Vm *VmSession) ParseToml(toml string, key string) ([]byte, error) {
+	return _Vm.Contract.ParseToml(&_Vm.CallOpts, toml, key)
+}
+
+// ParseToml is a free data retrieval call binding the contract method 0x37736e08.
+//
+// Solidity: function parseToml(string toml, string key) pure returns(bytes abiEncodedData)
+func (_Vm *VmCallerSession) ParseToml(toml string, key string) ([]byte, error) {
+	return _Vm.Contract.ParseToml(&_Vm.CallOpts, toml, key)
+}
+
+// ParseToml0 is a free data retrieval call binding the contract method 0x592151f0.
+//
+// Solidity: function parseToml(string toml) pure returns(bytes abiEncodedData)
+func (_Vm *VmCaller) ParseToml0(opts *bind.CallOpts, toml string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseToml0", toml)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseToml0 is a free data retrieval call binding the contract method 0x592151f0.
+//
+// Solidity: function parseToml(string toml) pure returns(bytes abiEncodedData)
+func (_Vm *VmSession) ParseToml0(toml string) ([]byte, error) {
+	return _Vm.Contract.ParseToml0(&_Vm.CallOpts, toml)
+}
+
+// ParseToml0 is a free data retrieval call binding the contract method 0x592151f0.
+//
+// Solidity: function parseToml(string toml) pure returns(bytes abiEncodedData)
+func (_Vm *VmCallerSession) ParseToml0(toml string) ([]byte, error) {
+	return _Vm.Contract.ParseToml0(&_Vm.CallOpts, toml)
+}
+
+// ParseTomlAddress is a free data retrieval call binding the contract method 0x65e7c844.
+//
+// Solidity: function parseTomlAddress(string toml, string key) pure returns(address)
+func (_Vm *VmCaller) ParseTomlAddress(opts *bind.CallOpts, toml string, key string) (common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlAddress", toml, key)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// ParseTomlAddress is a free data retrieval call binding the contract method 0x65e7c844.
+//
+// Solidity: function parseTomlAddress(string toml, string key) pure returns(address)
+func (_Vm *VmSession) ParseTomlAddress(toml string, key string) (common.Address, error) {
+	return _Vm.Contract.ParseTomlAddress(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlAddress is a free data retrieval call binding the contract method 0x65e7c844.
+//
+// Solidity: function parseTomlAddress(string toml, string key) pure returns(address)
+func (_Vm *VmCallerSession) ParseTomlAddress(toml string, key string) (common.Address, error) {
+	return _Vm.Contract.ParseTomlAddress(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlAddressArray is a free data retrieval call binding the contract method 0x65c428e7.
+//
+// Solidity: function parseTomlAddressArray(string toml, string key) pure returns(address[])
+func (_Vm *VmCaller) ParseTomlAddressArray(opts *bind.CallOpts, toml string, key string) ([]common.Address, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlAddressArray", toml, key)
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ParseTomlAddressArray is a free data retrieval call binding the contract method 0x65c428e7.
+//
+// Solidity: function parseTomlAddressArray(string toml, string key) pure returns(address[])
+func (_Vm *VmSession) ParseTomlAddressArray(toml string, key string) ([]common.Address, error) {
+	return _Vm.Contract.ParseTomlAddressArray(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlAddressArray is a free data retrieval call binding the contract method 0x65c428e7.
+//
+// Solidity: function parseTomlAddressArray(string toml, string key) pure returns(address[])
+func (_Vm *VmCallerSession) ParseTomlAddressArray(toml string, key string) ([]common.Address, error) {
+	return _Vm.Contract.ParseTomlAddressArray(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlBool is a free data retrieval call binding the contract method 0xd30dced6.
+//
+// Solidity: function parseTomlBool(string toml, string key) pure returns(bool)
+func (_Vm *VmCaller) ParseTomlBool(opts *bind.CallOpts, toml string, key string) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlBool", toml, key)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// ParseTomlBool is a free data retrieval call binding the contract method 0xd30dced6.
+//
+// Solidity: function parseTomlBool(string toml, string key) pure returns(bool)
+func (_Vm *VmSession) ParseTomlBool(toml string, key string) (bool, error) {
+	return _Vm.Contract.ParseTomlBool(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlBool is a free data retrieval call binding the contract method 0xd30dced6.
+//
+// Solidity: function parseTomlBool(string toml, string key) pure returns(bool)
+func (_Vm *VmCallerSession) ParseTomlBool(toml string, key string) (bool, error) {
+	return _Vm.Contract.ParseTomlBool(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlBoolArray is a free data retrieval call binding the contract method 0x127cfe9a.
+//
+// Solidity: function parseTomlBoolArray(string toml, string key) pure returns(bool[])
+func (_Vm *VmCaller) ParseTomlBoolArray(opts *bind.CallOpts, toml string, key string) ([]bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlBoolArray", toml, key)
+
+	if err != nil {
+		return *new([]bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool)
+
+	return out0, err
+
+}
+
+// ParseTomlBoolArray is a free data retrieval call binding the contract method 0x127cfe9a.
+//
+// Solidity: function parseTomlBoolArray(string toml, string key) pure returns(bool[])
+func (_Vm *VmSession) ParseTomlBoolArray(toml string, key string) ([]bool, error) {
+	return _Vm.Contract.ParseTomlBoolArray(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlBoolArray is a free data retrieval call binding the contract method 0x127cfe9a.
+//
+// Solidity: function parseTomlBoolArray(string toml, string key) pure returns(bool[])
+func (_Vm *VmCallerSession) ParseTomlBoolArray(toml string, key string) ([]bool, error) {
+	return _Vm.Contract.ParseTomlBoolArray(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlBytes is a free data retrieval call binding the contract method 0xd77bfdb9.
+//
+// Solidity: function parseTomlBytes(string toml, string key) pure returns(bytes)
+func (_Vm *VmCaller) ParseTomlBytes(opts *bind.CallOpts, toml string, key string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlBytes", toml, key)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlBytes is a free data retrieval call binding the contract method 0xd77bfdb9.
+//
+// Solidity: function parseTomlBytes(string toml, string key) pure returns(bytes)
+func (_Vm *VmSession) ParseTomlBytes(toml string, key string) ([]byte, error) {
+	return _Vm.Contract.ParseTomlBytes(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlBytes is a free data retrieval call binding the contract method 0xd77bfdb9.
+//
+// Solidity: function parseTomlBytes(string toml, string key) pure returns(bytes)
+func (_Vm *VmCallerSession) ParseTomlBytes(toml string, key string) ([]byte, error) {
+	return _Vm.Contract.ParseTomlBytes(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlBytes32 is a free data retrieval call binding the contract method 0x8e214810.
+//
+// Solidity: function parseTomlBytes32(string toml, string key) pure returns(bytes32)
+func (_Vm *VmCaller) ParseTomlBytes32(opts *bind.CallOpts, toml string, key string) ([32]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlBytes32", toml, key)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlBytes32 is a free data retrieval call binding the contract method 0x8e214810.
+//
+// Solidity: function parseTomlBytes32(string toml, string key) pure returns(bytes32)
+func (_Vm *VmSession) ParseTomlBytes32(toml string, key string) ([32]byte, error) {
+	return _Vm.Contract.ParseTomlBytes32(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlBytes32 is a free data retrieval call binding the contract method 0x8e214810.
+//
+// Solidity: function parseTomlBytes32(string toml, string key) pure returns(bytes32)
+func (_Vm *VmCallerSession) ParseTomlBytes32(toml string, key string) ([32]byte, error) {
+	return _Vm.Contract.ParseTomlBytes32(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlBytes32Array is a free data retrieval call binding the contract method 0x3e716f81.
+//
+// Solidity: function parseTomlBytes32Array(string toml, string key) pure returns(bytes32[])
+func (_Vm *VmCaller) ParseTomlBytes32Array(opts *bind.CallOpts, toml string, key string) ([][32]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlBytes32Array", toml, key)
+
+	if err != nil {
+		return *new([][32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlBytes32Array is a free data retrieval call binding the contract method 0x3e716f81.
+//
+// Solidity: function parseTomlBytes32Array(string toml, string key) pure returns(bytes32[])
+func (_Vm *VmSession) ParseTomlBytes32Array(toml string, key string) ([][32]byte, error) {
+	return _Vm.Contract.ParseTomlBytes32Array(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlBytes32Array is a free data retrieval call binding the contract method 0x3e716f81.
+//
+// Solidity: function parseTomlBytes32Array(string toml, string key) pure returns(bytes32[])
+func (_Vm *VmCallerSession) ParseTomlBytes32Array(toml string, key string) ([][32]byte, error) {
+	return _Vm.Contract.ParseTomlBytes32Array(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlBytesArray is a free data retrieval call binding the contract method 0xb197c247.
+//
+// Solidity: function parseTomlBytesArray(string toml, string key) pure returns(bytes[])
+func (_Vm *VmCaller) ParseTomlBytesArray(opts *bind.CallOpts, toml string, key string) ([][]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlBytesArray", toml, key)
+
+	if err != nil {
+		return *new([][]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlBytesArray is a free data retrieval call binding the contract method 0xb197c247.
+//
+// Solidity: function parseTomlBytesArray(string toml, string key) pure returns(bytes[])
+func (_Vm *VmSession) ParseTomlBytesArray(toml string, key string) ([][]byte, error) {
+	return _Vm.Contract.ParseTomlBytesArray(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlBytesArray is a free data retrieval call binding the contract method 0xb197c247.
+//
+// Solidity: function parseTomlBytesArray(string toml, string key) pure returns(bytes[])
+func (_Vm *VmCallerSession) ParseTomlBytesArray(toml string, key string) ([][]byte, error) {
+	return _Vm.Contract.ParseTomlBytesArray(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlInt is a free data retrieval call binding the contract method 0xc1350739.
+//
+// Solidity: function parseTomlInt(string toml, string key) pure returns(int256)
+func (_Vm *VmCaller) ParseTomlInt(opts *bind.CallOpts, toml string, key string) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlInt", toml, key)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ParseTomlInt is a free data retrieval call binding the contract method 0xc1350739.
+//
+// Solidity: function parseTomlInt(string toml, string key) pure returns(int256)
+func (_Vm *VmSession) ParseTomlInt(toml string, key string) (*big.Int, error) {
+	return _Vm.Contract.ParseTomlInt(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlInt is a free data retrieval call binding the contract method 0xc1350739.
+//
+// Solidity: function parseTomlInt(string toml, string key) pure returns(int256)
+func (_Vm *VmCallerSession) ParseTomlInt(toml string, key string) (*big.Int, error) {
+	return _Vm.Contract.ParseTomlInt(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlIntArray is a free data retrieval call binding the contract method 0xd3522ae6.
+//
+// Solidity: function parseTomlIntArray(string toml, string key) pure returns(int256[])
+func (_Vm *VmCaller) ParseTomlIntArray(opts *bind.CallOpts, toml string, key string) ([]*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlIntArray", toml, key)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// ParseTomlIntArray is a free data retrieval call binding the contract method 0xd3522ae6.
+//
+// Solidity: function parseTomlIntArray(string toml, string key) pure returns(int256[])
+func (_Vm *VmSession) ParseTomlIntArray(toml string, key string) ([]*big.Int, error) {
+	return _Vm.Contract.ParseTomlIntArray(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlIntArray is a free data retrieval call binding the contract method 0xd3522ae6.
+//
+// Solidity: function parseTomlIntArray(string toml, string key) pure returns(int256[])
+func (_Vm *VmCallerSession) ParseTomlIntArray(toml string, key string) ([]*big.Int, error) {
+	return _Vm.Contract.ParseTomlIntArray(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlKeys is a free data retrieval call binding the contract method 0x812a44b2.
+//
+// Solidity: function parseTomlKeys(string toml, string key) pure returns(string[] keys)
+func (_Vm *VmCaller) ParseTomlKeys(opts *bind.CallOpts, toml string, key string) ([]string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlKeys", toml, key)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ParseTomlKeys is a free data retrieval call binding the contract method 0x812a44b2.
+//
+// Solidity: function parseTomlKeys(string toml, string key) pure returns(string[] keys)
+func (_Vm *VmSession) ParseTomlKeys(toml string, key string) ([]string, error) {
+	return _Vm.Contract.ParseTomlKeys(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlKeys is a free data retrieval call binding the contract method 0x812a44b2.
+//
+// Solidity: function parseTomlKeys(string toml, string key) pure returns(string[] keys)
+func (_Vm *VmCallerSession) ParseTomlKeys(toml string, key string) ([]string, error) {
+	return _Vm.Contract.ParseTomlKeys(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlString is a free data retrieval call binding the contract method 0x8bb8dd43.
+//
+// Solidity: function parseTomlString(string toml, string key) pure returns(string)
+func (_Vm *VmCaller) ParseTomlString(opts *bind.CallOpts, toml string, key string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlString", toml, key)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ParseTomlString is a free data retrieval call binding the contract method 0x8bb8dd43.
+//
+// Solidity: function parseTomlString(string toml, string key) pure returns(string)
+func (_Vm *VmSession) ParseTomlString(toml string, key string) (string, error) {
+	return _Vm.Contract.ParseTomlString(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlString is a free data retrieval call binding the contract method 0x8bb8dd43.
+//
+// Solidity: function parseTomlString(string toml, string key) pure returns(string)
+func (_Vm *VmCallerSession) ParseTomlString(toml string, key string) (string, error) {
+	return _Vm.Contract.ParseTomlString(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlStringArray is a free data retrieval call binding the contract method 0x9f629281.
+//
+// Solidity: function parseTomlStringArray(string toml, string key) pure returns(string[])
+func (_Vm *VmCaller) ParseTomlStringArray(opts *bind.CallOpts, toml string, key string) ([]string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlStringArray", toml, key)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ParseTomlStringArray is a free data retrieval call binding the contract method 0x9f629281.
+//
+// Solidity: function parseTomlStringArray(string toml, string key) pure returns(string[])
+func (_Vm *VmSession) ParseTomlStringArray(toml string, key string) ([]string, error) {
+	return _Vm.Contract.ParseTomlStringArray(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlStringArray is a free data retrieval call binding the contract method 0x9f629281.
+//
+// Solidity: function parseTomlStringArray(string toml, string key) pure returns(string[])
+func (_Vm *VmCallerSession) ParseTomlStringArray(toml string, key string) ([]string, error) {
+	return _Vm.Contract.ParseTomlStringArray(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlType is a free data retrieval call binding the contract method 0x47fa5e11.
+//
+// Solidity: function parseTomlType(string toml, string typeDescription) pure returns(bytes)
+func (_Vm *VmCaller) ParseTomlType(opts *bind.CallOpts, toml string, typeDescription string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlType", toml, typeDescription)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlType is a free data retrieval call binding the contract method 0x47fa5e11.
+//
+// Solidity: function parseTomlType(string toml, string typeDescription) pure returns(bytes)
+func (_Vm *VmSession) ParseTomlType(toml string, typeDescription string) ([]byte, error) {
+	return _Vm.Contract.ParseTomlType(&_Vm.CallOpts, toml, typeDescription)
+}
+
+// ParseTomlType is a free data retrieval call binding the contract method 0x47fa5e11.
+//
+// Solidity: function parseTomlType(string toml, string typeDescription) pure returns(bytes)
+func (_Vm *VmCallerSession) ParseTomlType(toml string, typeDescription string) ([]byte, error) {
+	return _Vm.Contract.ParseTomlType(&_Vm.CallOpts, toml, typeDescription)
+}
+
+// ParseTomlType0 is a free data retrieval call binding the contract method 0xf9fa5cdb.
+//
+// Solidity: function parseTomlType(string toml, string key, string typeDescription) pure returns(bytes)
+func (_Vm *VmCaller) ParseTomlType0(opts *bind.CallOpts, toml string, key string, typeDescription string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlType0", toml, key, typeDescription)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlType0 is a free data retrieval call binding the contract method 0xf9fa5cdb.
+//
+// Solidity: function parseTomlType(string toml, string key, string typeDescription) pure returns(bytes)
+func (_Vm *VmSession) ParseTomlType0(toml string, key string, typeDescription string) ([]byte, error) {
+	return _Vm.Contract.ParseTomlType0(&_Vm.CallOpts, toml, key, typeDescription)
+}
+
+// ParseTomlType0 is a free data retrieval call binding the contract method 0xf9fa5cdb.
+//
+// Solidity: function parseTomlType(string toml, string key, string typeDescription) pure returns(bytes)
+func (_Vm *VmCallerSession) ParseTomlType0(toml string, key string, typeDescription string) ([]byte, error) {
+	return _Vm.Contract.ParseTomlType0(&_Vm.CallOpts, toml, key, typeDescription)
+}
+
+// ParseTomlTypeArray is a free data retrieval call binding the contract method 0x49be3743.
+//
+// Solidity: function parseTomlTypeArray(string toml, string key, string typeDescription) pure returns(bytes)
+func (_Vm *VmCaller) ParseTomlTypeArray(opts *bind.CallOpts, toml string, key string, typeDescription string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlTypeArray", toml, key, typeDescription)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlTypeArray is a free data retrieval call binding the contract method 0x49be3743.
+//
+// Solidity: function parseTomlTypeArray(string toml, string key, string typeDescription) pure returns(bytes)
+func (_Vm *VmSession) ParseTomlTypeArray(toml string, key string, typeDescription string) ([]byte, error) {
+	return _Vm.Contract.ParseTomlTypeArray(&_Vm.CallOpts, toml, key, typeDescription)
+}
+
+// ParseTomlTypeArray is a free data retrieval call binding the contract method 0x49be3743.
+//
+// Solidity: function parseTomlTypeArray(string toml, string key, string typeDescription) pure returns(bytes)
+func (_Vm *VmCallerSession) ParseTomlTypeArray(toml string, key string, typeDescription string) ([]byte, error) {
+	return _Vm.Contract.ParseTomlTypeArray(&_Vm.CallOpts, toml, key, typeDescription)
+}
+
+// ParseTomlUint is a free data retrieval call binding the contract method 0xcc7b0487.
+//
+// Solidity: function parseTomlUint(string toml, string key) pure returns(uint256)
+func (_Vm *VmCaller) ParseTomlUint(opts *bind.CallOpts, toml string, key string) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlUint", toml, key)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ParseTomlUint is a free data retrieval call binding the contract method 0xcc7b0487.
+//
+// Solidity: function parseTomlUint(string toml, string key) pure returns(uint256)
+func (_Vm *VmSession) ParseTomlUint(toml string, key string) (*big.Int, error) {
+	return _Vm.Contract.ParseTomlUint(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlUint is a free data retrieval call binding the contract method 0xcc7b0487.
+//
+// Solidity: function parseTomlUint(string toml, string key) pure returns(uint256)
+func (_Vm *VmCallerSession) ParseTomlUint(toml string, key string) (*big.Int, error) {
+	return _Vm.Contract.ParseTomlUint(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlUintArray is a free data retrieval call binding the contract method 0xb5df27c8.
+//
+// Solidity: function parseTomlUintArray(string toml, string key) pure returns(uint256[])
+func (_Vm *VmCaller) ParseTomlUintArray(opts *bind.CallOpts, toml string, key string) ([]*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseTomlUintArray", toml, key)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// ParseTomlUintArray is a free data retrieval call binding the contract method 0xb5df27c8.
+//
+// Solidity: function parseTomlUintArray(string toml, string key) pure returns(uint256[])
+func (_Vm *VmSession) ParseTomlUintArray(toml string, key string) ([]*big.Int, error) {
+	return _Vm.Contract.ParseTomlUintArray(&_Vm.CallOpts, toml, key)
+}
+
+// ParseTomlUintArray is a free data retrieval call binding the contract method 0xb5df27c8.
+//
+// Solidity: function parseTomlUintArray(string toml, string key) pure returns(uint256[])
+func (_Vm *VmCallerSession) ParseTomlUintArray(toml string, key string) ([]*big.Int, error) {
+	return _Vm.Contract.ParseTomlUintArray(&_Vm.CallOpts, toml, key)
+}
+
+// ParseUint is a free data retrieval call binding the contract method 0xfa91454d.
+//
+// Solidity: function parseUint(string stringifiedValue) pure returns(uint256 parsedValue)
+func (_Vm *VmCaller) ParseUint(opts *bind.CallOpts, stringifiedValue string) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "parseUint", stringifiedValue)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ParseUint is a free data retrieval call binding the contract method 0xfa91454d.
+//
+// Solidity: function parseUint(string stringifiedValue) pure returns(uint256 parsedValue)
+func (_Vm *VmSession) ParseUint(stringifiedValue string) (*big.Int, error) {
+	return _Vm.Contract.ParseUint(&_Vm.CallOpts, stringifiedValue)
+}
+
+// ParseUint is a free data retrieval call binding the contract method 0xfa91454d.
+//
+// Solidity: function parseUint(string stringifiedValue) pure returns(uint256 parsedValue)
+func (_Vm *VmCallerSession) ParseUint(stringifiedValue string) (*big.Int, error) {
+	return _Vm.Contract.ParseUint(&_Vm.CallOpts, stringifiedValue)
+}
+
+// PauseTracing is a free data retrieval call binding the contract method 0xc94d1f90.
+//
+// Solidity: function pauseTracing() view returns()
+func (_Vm *VmCaller) PauseTracing(opts *bind.CallOpts) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "pauseTracing")
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// PauseTracing is a free data retrieval call binding the contract method 0xc94d1f90.
+//
+// Solidity: function pauseTracing() view returns()
+func (_Vm *VmSession) PauseTracing() error {
+	return _Vm.Contract.PauseTracing(&_Vm.CallOpts)
+}
+
+// PauseTracing is a free data retrieval call binding the contract method 0xc94d1f90.
+//
+// Solidity: function pauseTracing() view returns()
+func (_Vm *VmCallerSession) PauseTracing() error {
+	return _Vm.Contract.PauseTracing(&_Vm.CallOpts)
+}
+
+// ProjectRoot is a free data retrieval call binding the contract method 0xd930a0e6.
+//
+// Solidity: function projectRoot() view returns(string path)
+func (_Vm *VmCaller) ProjectRoot(opts *bind.CallOpts) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "projectRoot")
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ProjectRoot is a free data retrieval call binding the contract method 0xd930a0e6.
+//
+// Solidity: function projectRoot() view returns(string path)
+func (_Vm *VmSession) ProjectRoot() (string, error) {
+	return _Vm.Contract.ProjectRoot(&_Vm.CallOpts)
+}
+
+// ProjectRoot is a free data retrieval call binding the contract method 0xd930a0e6.
+//
+// Solidity: function projectRoot() view returns(string path)
+func (_Vm *VmCallerSession) ProjectRoot() (string, error) {
+	return _Vm.Contract.ProjectRoot(&_Vm.CallOpts)
+}
+
+// PublicKeyP256 is a free data retrieval call binding the contract method 0xc453949e.
+//
+// Solidity: function publicKeyP256(uint256 privateKey) pure returns(uint256 publicKeyX, uint256 publicKeyY)
+func (_Vm *VmCaller) PublicKeyP256(opts *bind.CallOpts, privateKey *big.Int) (struct {
+	PublicKeyX *big.Int
+	PublicKeyY *big.Int
+}, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "publicKeyP256", privateKey)
+
+	outstruct := new(struct {
+		PublicKeyX *big.Int
+		PublicKeyY *big.Int
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.PublicKeyX = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+	outstruct.PublicKeyY = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int)
+
+	return *outstruct, err
+
+}
+
+// PublicKeyP256 is a free data retrieval call binding the contract method 0xc453949e.
+//
+// Solidity: function publicKeyP256(uint256 privateKey) pure returns(uint256 publicKeyX, uint256 publicKeyY)
+func (_Vm *VmSession) PublicKeyP256(privateKey *big.Int) (struct {
+	PublicKeyX *big.Int
+	PublicKeyY *big.Int
+}, error) {
+	return _Vm.Contract.PublicKeyP256(&_Vm.CallOpts, privateKey)
+}
+
+// PublicKeyP256 is a free data retrieval call binding the contract method 0xc453949e.
+//
+// Solidity: function publicKeyP256(uint256 privateKey) pure returns(uint256 publicKeyX, uint256 publicKeyY)
+func (_Vm *VmCallerSession) PublicKeyP256(privateKey *big.Int) (struct {
+	PublicKeyX *big.Int
+	PublicKeyY *big.Int
+}, error) {
+	return _Vm.Contract.PublicKeyP256(&_Vm.CallOpts, privateKey)
+}
+
+// RandomBool is a free data retrieval call binding the contract method 0xcdc126bd.
+//
+// Solidity: function randomBool() view returns(bool)
+func (_Vm *VmCaller) RandomBool(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "randomBool")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RandomBool is a free data retrieval call binding the contract method 0xcdc126bd.
+//
+// Solidity: function randomBool() view returns(bool)
+func (_Vm *VmSession) RandomBool() (bool, error) {
+	return _Vm.Contract.RandomBool(&_Vm.CallOpts)
+}
+
+// RandomBool is a free data retrieval call binding the contract method 0xcdc126bd.
+//
+// Solidity: function randomBool() view returns(bool)
+func (_Vm *VmCallerSession) RandomBool() (bool, error) {
+	return _Vm.Contract.RandomBool(&_Vm.CallOpts)
+}
+
+// RandomBytes is a free data retrieval call binding the contract method 0x6c5d32a9.
+//
+// Solidity: function randomBytes(uint256 len) view returns(bytes)
+func (_Vm *VmCaller) RandomBytes(opts *bind.CallOpts, len *big.Int) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "randomBytes", len)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// RandomBytes is a free data retrieval call binding the contract method 0x6c5d32a9.
+//
+// Solidity: function randomBytes(uint256 len) view returns(bytes)
+func (_Vm *VmSession) RandomBytes(len *big.Int) ([]byte, error) {
+	return _Vm.Contract.RandomBytes(&_Vm.CallOpts, len)
+}
+
+// RandomBytes is a free data retrieval call binding the contract method 0x6c5d32a9.
+//
+// Solidity: function randomBytes(uint256 len) view returns(bytes)
+func (_Vm *VmCallerSession) RandomBytes(len *big.Int) ([]byte, error) {
+	return _Vm.Contract.RandomBytes(&_Vm.CallOpts, len)
+}
+
+// RandomBytes4 is a free data retrieval call binding the contract method 0x9b7cd579.
+//
+// Solidity: function randomBytes4() view returns(bytes4)
+func (_Vm *VmCaller) RandomBytes4(opts *bind.CallOpts) ([4]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "randomBytes4")
+
+	if err != nil {
+		return *new([4]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([4]byte)).(*[4]byte)
+
+	return out0, err
+
+}
+
+// RandomBytes4 is a free data retrieval call binding the contract method 0x9b7cd579.
+//
+// Solidity: function randomBytes4() view returns(bytes4)
+func (_Vm *VmSession) RandomBytes4() ([4]byte, error) {
+	return _Vm.Contract.RandomBytes4(&_Vm.CallOpts)
+}
+
+// RandomBytes4 is a free data retrieval call binding the contract method 0x9b7cd579.
+//
+// Solidity: function randomBytes4() view returns(bytes4)
+func (_Vm *VmCallerSession) RandomBytes4() ([4]byte, error) {
+	return _Vm.Contract.RandomBytes4(&_Vm.CallOpts)
+}
+
+// RandomBytes8 is a free data retrieval call binding the contract method 0x0497b0a5.
+//
+// Solidity: function randomBytes8() view returns(bytes8)
+func (_Vm *VmCaller) RandomBytes8(opts *bind.CallOpts) ([8]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "randomBytes8")
+
+	if err != nil {
+		return *new([8]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([8]byte)).(*[8]byte)
+
+	return out0, err
+
+}
+
+// RandomBytes8 is a free data retrieval call binding the contract method 0x0497b0a5.
+//
+// Solidity: function randomBytes8() view returns(bytes8)
+func (_Vm *VmSession) RandomBytes8() ([8]byte, error) {
+	return _Vm.Contract.RandomBytes8(&_Vm.CallOpts)
+}
+
+// RandomBytes8 is a free data retrieval call binding the contract method 0x0497b0a5.
+//
+// Solidity: function randomBytes8() view returns(bytes8)
+func (_Vm *VmCallerSession) RandomBytes8() ([8]byte, error) {
+	return _Vm.Contract.RandomBytes8(&_Vm.CallOpts)
+}
+
+// RandomInt is a free data retrieval call binding the contract method 0x111f1202.
+//
+// Solidity: function randomInt() view returns(int256)
+func (_Vm *VmCaller) RandomInt(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "randomInt")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// RandomInt is a free data retrieval call binding the contract method 0x111f1202.
+//
+// Solidity: function randomInt() view returns(int256)
+func (_Vm *VmSession) RandomInt() (*big.Int, error) {
+	return _Vm.Contract.RandomInt(&_Vm.CallOpts)
+}
+
+// RandomInt is a free data retrieval call binding the contract method 0x111f1202.
+//
+// Solidity: function randomInt() view returns(int256)
+func (_Vm *VmCallerSession) RandomInt() (*big.Int, error) {
+	return _Vm.Contract.RandomInt(&_Vm.CallOpts)
+}
+
+// RandomInt0 is a free data retrieval call binding the contract method 0x12845966.
+//
+// Solidity: function randomInt(uint256 bits) view returns(int256)
+func (_Vm *VmCaller) RandomInt0(opts *bind.CallOpts, bits *big.Int) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "randomInt0", bits)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// RandomInt0 is a free data retrieval call binding the contract method 0x12845966.
+//
+// Solidity: function randomInt(uint256 bits) view returns(int256)
+func (_Vm *VmSession) RandomInt0(bits *big.Int) (*big.Int, error) {
+	return _Vm.Contract.RandomInt0(&_Vm.CallOpts, bits)
+}
+
+// RandomInt0 is a free data retrieval call binding the contract method 0x12845966.
+//
+// Solidity: function randomInt(uint256 bits) view returns(int256)
+func (_Vm *VmCallerSession) RandomInt0(bits *big.Int) (*big.Int, error) {
+	return _Vm.Contract.RandomInt0(&_Vm.CallOpts, bits)
+}
+
+// RandomUint0 is a free data retrieval call binding the contract method 0xcf81e69c.
+//
+// Solidity: function randomUint(uint256 bits) view returns(uint256)
+func (_Vm *VmCaller) RandomUint0(opts *bind.CallOpts, bits *big.Int) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "randomUint0", bits)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// RandomUint0 is a free data retrieval call binding the contract method 0xcf81e69c.
+//
+// Solidity: function randomUint(uint256 bits) view returns(uint256)
+func (_Vm *VmSession) RandomUint0(bits *big.Int) (*big.Int, error) {
+	return _Vm.Contract.RandomUint0(&_Vm.CallOpts, bits)
+}
+
+// RandomUint0 is a free data retrieval call binding the contract method 0xcf81e69c.
+//
+// Solidity: function randomUint(uint256 bits) view returns(uint256)
+func (_Vm *VmCallerSession) RandomUint0(bits *big.Int) (*big.Int, error) {
+	return _Vm.Contract.RandomUint0(&_Vm.CallOpts, bits)
+}
+
+// ReadDir is a free data retrieval call binding the contract method 0x1497876c.
+//
+// Solidity: function readDir(string path, uint64 maxDepth) view returns((string,string,uint64,bool,bool)[] entries)
+func (_Vm *VmCaller) ReadDir(opts *bind.CallOpts, path string, maxDepth uint64) ([]VmSafeDirEntry, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "readDir", path, maxDepth)
+
+	if err != nil {
+		return *new([]VmSafeDirEntry), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]VmSafeDirEntry)).(*[]VmSafeDirEntry)
+
+	return out0, err
+
+}
+
+// ReadDir is a free data retrieval call binding the contract method 0x1497876c.
+//
+// Solidity: function readDir(string path, uint64 maxDepth) view returns((string,string,uint64,bool,bool)[] entries)
+func (_Vm *VmSession) ReadDir(path string, maxDepth uint64) ([]VmSafeDirEntry, error) {
+	return _Vm.Contract.ReadDir(&_Vm.CallOpts, path, maxDepth)
+}
+
+// ReadDir is a free data retrieval call binding the contract method 0x1497876c.
+//
+// Solidity: function readDir(string path, uint64 maxDepth) view returns((string,string,uint64,bool,bool)[] entries)
+func (_Vm *VmCallerSession) ReadDir(path string, maxDepth uint64) ([]VmSafeDirEntry, error) {
+	return _Vm.Contract.ReadDir(&_Vm.CallOpts, path, maxDepth)
+}
+
+// ReadDir0 is a free data retrieval call binding the contract method 0x8102d70d.
+//
+// Solidity: function readDir(string path, uint64 maxDepth, bool followLinks) view returns((string,string,uint64,bool,bool)[] entries)
+func (_Vm *VmCaller) ReadDir0(opts *bind.CallOpts, path string, maxDepth uint64, followLinks bool) ([]VmSafeDirEntry, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "readDir0", path, maxDepth, followLinks)
+
+	if err != nil {
+		return *new([]VmSafeDirEntry), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]VmSafeDirEntry)).(*[]VmSafeDirEntry)
+
+	return out0, err
+
+}
+
+// ReadDir0 is a free data retrieval call binding the contract method 0x8102d70d.
+//
+// Solidity: function readDir(string path, uint64 maxDepth, bool followLinks) view returns((string,string,uint64,bool,bool)[] entries)
+func (_Vm *VmSession) ReadDir0(path string, maxDepth uint64, followLinks bool) ([]VmSafeDirEntry, error) {
+	return _Vm.Contract.ReadDir0(&_Vm.CallOpts, path, maxDepth, followLinks)
+}
+
+// ReadDir0 is a free data retrieval call binding the contract method 0x8102d70d.
+//
+// Solidity: function readDir(string path, uint64 maxDepth, bool followLinks) view returns((string,string,uint64,bool,bool)[] entries)
+func (_Vm *VmCallerSession) ReadDir0(path string, maxDepth uint64, followLinks bool) ([]VmSafeDirEntry, error) {
+	return _Vm.Contract.ReadDir0(&_Vm.CallOpts, path, maxDepth, followLinks)
+}
+
+// ReadDir1 is a free data retrieval call binding the contract method 0xc4bc59e0.
+//
+// Solidity: function readDir(string path) view returns((string,string,uint64,bool,bool)[] entries)
+func (_Vm *VmCaller) ReadDir1(opts *bind.CallOpts, path string) ([]VmSafeDirEntry, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "readDir1", path)
+
+	if err != nil {
+		return *new([]VmSafeDirEntry), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]VmSafeDirEntry)).(*[]VmSafeDirEntry)
+
+	return out0, err
+
+}
+
+// ReadDir1 is a free data retrieval call binding the contract method 0xc4bc59e0.
+//
+// Solidity: function readDir(string path) view returns((string,string,uint64,bool,bool)[] entries)
+func (_Vm *VmSession) ReadDir1(path string) ([]VmSafeDirEntry, error) {
+	return _Vm.Contract.ReadDir1(&_Vm.CallOpts, path)
+}
+
+// ReadDir1 is a free data retrieval call binding the contract method 0xc4bc59e0.
+//
+// Solidity: function readDir(string path) view returns((string,string,uint64,bool,bool)[] entries)
+func (_Vm *VmCallerSession) ReadDir1(path string) ([]VmSafeDirEntry, error) {
+	return _Vm.Contract.ReadDir1(&_Vm.CallOpts, path)
+}
+
+// ReadFile is a free data retrieval call binding the contract method 0x60f9bb11.
+//
+// Solidity: function readFile(string path) view returns(string data)
+func (_Vm *VmCaller) ReadFile(opts *bind.CallOpts, path string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "readFile", path)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ReadFile is a free data retrieval call binding the contract method 0x60f9bb11.
+//
+// Solidity: function readFile(string path) view returns(string data)
+func (_Vm *VmSession) ReadFile(path string) (string, error) {
+	return _Vm.Contract.ReadFile(&_Vm.CallOpts, path)
+}
+
+// ReadFile is a free data retrieval call binding the contract method 0x60f9bb11.
+//
+// Solidity: function readFile(string path) view returns(string data)
+func (_Vm *VmCallerSession) ReadFile(path string) (string, error) {
+	return _Vm.Contract.ReadFile(&_Vm.CallOpts, path)
+}
+
+// ReadFileBinary is a free data retrieval call binding the contract method 0x16ed7bc4.
+//
+// Solidity: function readFileBinary(string path) view returns(bytes data)
+func (_Vm *VmCaller) ReadFileBinary(opts *bind.CallOpts, path string) ([]byte, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "readFileBinary", path)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ReadFileBinary is a free data retrieval call binding the contract method 0x16ed7bc4.
+//
+// Solidity: function readFileBinary(string path) view returns(bytes data)
+func (_Vm *VmSession) ReadFileBinary(path string) ([]byte, error) {
+	return _Vm.Contract.ReadFileBinary(&_Vm.CallOpts, path)
+}
+
+// ReadFileBinary is a free data retrieval call binding the contract method 0x16ed7bc4.
+//
+// Solidity: function readFileBinary(string path) view returns(bytes data)
+func (_Vm *VmCallerSession) ReadFileBinary(path string) ([]byte, error) {
+	return _Vm.Contract.ReadFileBinary(&_Vm.CallOpts, path)
+}
+
+// ReadLine is a free data retrieval call binding the contract method 0x70f55728.
+//
+// Solidity: function readLine(string path) view returns(string line)
+func (_Vm *VmCaller) ReadLine(opts *bind.CallOpts, path string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "readLine", path)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ReadLine is a free data retrieval call binding the contract method 0x70f55728.
+//
+// Solidity: function readLine(string path) view returns(string line)
+func (_Vm *VmSession) ReadLine(path string) (string, error) {
+	return _Vm.Contract.ReadLine(&_Vm.CallOpts, path)
+}
+
+// ReadLine is a free data retrieval call binding the contract method 0x70f55728.
+//
+// Solidity: function readLine(string path) view returns(string line)
+func (_Vm *VmCallerSession) ReadLine(path string) (string, error) {
+	return _Vm.Contract.ReadLine(&_Vm.CallOpts, path)
+}
+
+// ReadLink is a free data retrieval call binding the contract method 0x9f5684a2.
+//
+// Solidity: function readLink(string linkPath) view returns(string targetPath)
+func (_Vm *VmCaller) ReadLink(opts *bind.CallOpts, linkPath string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "readLink", linkPath)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ReadLink is a free data retrieval call binding the contract method 0x9f5684a2.
+//
+// Solidity: function readLink(string linkPath) view returns(string targetPath)
+func (_Vm *VmSession) ReadLink(linkPath string) (string, error) {
+	return _Vm.Contract.ReadLink(&_Vm.CallOpts, linkPath)
+}
+
+// ReadLink is a free data retrieval call binding the contract method 0x9f5684a2.
+//
+// Solidity: function readLink(string linkPath) view returns(string targetPath)
+func (_Vm *VmCallerSession) ReadLink(linkPath string) (string, error) {
+	return _Vm.Contract.ReadLink(&_Vm.CallOpts, linkPath)
+}
+
+// Replace is a free data retrieval call binding the contract method 0xe00ad03e.
+//
+// Solidity: function replace(string input, string from, string to) pure returns(string output)
+func (_Vm *VmCaller) Replace(opts *bind.CallOpts, input string, from string, to string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "replace", input, from, to)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// Replace is a free data retrieval call binding the contract method 0xe00ad03e.
+//
+// Solidity: function replace(string input, string from, string to) pure returns(string output)
+func (_Vm *VmSession) Replace(input string, from string, to string) (string, error) {
+	return _Vm.Contract.Replace(&_Vm.CallOpts, input, from, to)
+}
+
+// Replace is a free data retrieval call binding the contract method 0xe00ad03e.
+//
+// Solidity: function replace(string input, string from, string to) pure returns(string output)
+func (_Vm *VmCallerSession) Replace(input string, from string, to string) (string, error) {
+	return _Vm.Contract.Replace(&_Vm.CallOpts, input, from, to)
+}
+
+// ResumeTracing is a free data retrieval call binding the contract method 0x72a09ccb.
+//
+// Solidity: function resumeTracing() view returns()
+func (_Vm *VmCaller) ResumeTracing(opts *bind.CallOpts) error {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "resumeTracing")
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// ResumeTracing is a free data retrieval call binding the contract method 0x72a09ccb.
+//
+// Solidity: function resumeTracing() view returns()
+func (_Vm *VmSession) ResumeTracing() error {
+	return _Vm.Contract.ResumeTracing(&_Vm.CallOpts)
+}
+
+// ResumeTracing is a free data retrieval call binding the contract method 0x72a09ccb.
+//
+// Solidity: function resumeTracing() view returns()
+func (_Vm *VmCallerSession) ResumeTracing() error {
+	return _Vm.Contract.ResumeTracing(&_Vm.CallOpts)
+}
+
+// RpcUrl is a free data retrieval call binding the contract method 0x975a6ce9.
+//
+// Solidity: function rpcUrl(string rpcAlias) view returns(string json)
+func (_Vm *VmCaller) RpcUrl(opts *bind.CallOpts, rpcAlias string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "rpcUrl", rpcAlias)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// RpcUrl is a free data retrieval call binding the contract method 0x975a6ce9.
+//
+// Solidity: function rpcUrl(string rpcAlias) view returns(string json)
+func (_Vm *VmSession) RpcUrl(rpcAlias string) (string, error) {
+	return _Vm.Contract.RpcUrl(&_Vm.CallOpts, rpcAlias)
+}
+
+// RpcUrl is a free data retrieval call binding the contract method 0x975a6ce9.
+//
+// Solidity: function rpcUrl(string rpcAlias) view returns(string json)
+func (_Vm *VmCallerSession) RpcUrl(rpcAlias string) (string, error) {
+	return _Vm.Contract.RpcUrl(&_Vm.CallOpts, rpcAlias)
+}
+
+// RpcUrlStructs is a free data retrieval call binding the contract method 0x9d2ad72a.
+//
+// Solidity: function rpcUrlStructs() view returns((string,string)[] urls)
+func (_Vm *VmCaller) RpcUrlStructs(opts *bind.CallOpts) ([]VmSafeRpc, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "rpcUrlStructs")
+
+	if err != nil {
+		return *new([]VmSafeRpc), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]VmSafeRpc)).(*[]VmSafeRpc)
+
+	return out0, err
+
+}
+
+// RpcUrlStructs is a free data retrieval call binding the contract method 0x9d2ad72a.
+//
+// Solidity: function rpcUrlStructs() view returns((string,string)[] urls)
+func (_Vm *VmSession) RpcUrlStructs() ([]VmSafeRpc, error) {
+	return _Vm.Contract.RpcUrlStructs(&_Vm.CallOpts)
+}
+
+// RpcUrlStructs is a free data retrieval call binding the contract method 0x9d2ad72a.
+//
+// Solidity: function rpcUrlStructs() view returns((string,string)[] urls)
+func (_Vm *VmCallerSession) RpcUrlStructs() ([]VmSafeRpc, error) {
+	return _Vm.Contract.RpcUrlStructs(&_Vm.CallOpts)
+}
+
+// RpcUrls is a free data retrieval call binding the contract method 0xa85a8418.
+//
+// Solidity: function rpcUrls() view returns(string[2][] urls)
+func (_Vm *VmCaller) RpcUrls(opts *bind.CallOpts) ([][2]string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "rpcUrls")
+
+	if err != nil {
+		return *new([][2]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][2]string)).(*[][2]string)
+
+	return out0, err
+
+}
+
+// RpcUrls is a free data retrieval call binding the contract method 0xa85a8418.
+//
+// Solidity: function rpcUrls() view returns(string[2][] urls)
+func (_Vm *VmSession) RpcUrls() ([][2]string, error) {
+	return _Vm.Contract.RpcUrls(&_Vm.CallOpts)
+}
+
+// RpcUrls is a free data retrieval call binding the contract method 0xa85a8418.
+//
+// Solidity: function rpcUrls() view returns(string[2][] urls)
+func (_Vm *VmCallerSession) RpcUrls() ([][2]string, error) {
+	return _Vm.Contract.RpcUrls(&_Vm.CallOpts)
+}
+
+// SerializeJsonType is a free data retrieval call binding the contract method 0x6d4f96a6.
+//
+// Solidity: function serializeJsonType(string typeDescription, bytes value) pure returns(string json)
+func (_Vm *VmCaller) SerializeJsonType(opts *bind.CallOpts, typeDescription string, value []byte) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "serializeJsonType", typeDescription, value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// SerializeJsonType is a free data retrieval call binding the contract method 0x6d4f96a6.
+//
+// Solidity: function serializeJsonType(string typeDescription, bytes value) pure returns(string json)
+func (_Vm *VmSession) SerializeJsonType(typeDescription string, value []byte) (string, error) {
+	return _Vm.Contract.SerializeJsonType(&_Vm.CallOpts, typeDescription, value)
+}
+
+// SerializeJsonType is a free data retrieval call binding the contract method 0x6d4f96a6.
+//
+// Solidity: function serializeJsonType(string typeDescription, bytes value) pure returns(string json)
+func (_Vm *VmCallerSession) SerializeJsonType(typeDescription string, value []byte) (string, error) {
+	return _Vm.Contract.SerializeJsonType(&_Vm.CallOpts, typeDescription, value)
+}
+
+// Sign is a free data retrieval call binding the contract method 0x799cd333.
+//
+// Solidity: function sign(bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_Vm *VmCaller) Sign(opts *bind.CallOpts, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "sign", digest)
+
+	outstruct := new(struct {
+		V uint8
+		R [32]byte
+		S [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.V = *abi.ConvertType(out[0], new(uint8)).(*uint8)
+	outstruct.R = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+	outstruct.S = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// Sign is a free data retrieval call binding the contract method 0x799cd333.
+//
+// Solidity: function sign(bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_Vm *VmSession) Sign(digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _Vm.Contract.Sign(&_Vm.CallOpts, digest)
+}
+
+// Sign is a free data retrieval call binding the contract method 0x799cd333.
+//
+// Solidity: function sign(bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_Vm *VmCallerSession) Sign(digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _Vm.Contract.Sign(&_Vm.CallOpts, digest)
+}
+
+// Sign0 is a free data retrieval call binding the contract method 0x8c1aa205.
+//
+// Solidity: function sign(address signer, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_Vm *VmCaller) Sign0(opts *bind.CallOpts, signer common.Address, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "sign0", signer, digest)
+
+	outstruct := new(struct {
+		V uint8
+		R [32]byte
+		S [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.V = *abi.ConvertType(out[0], new(uint8)).(*uint8)
+	outstruct.R = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+	outstruct.S = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// Sign0 is a free data retrieval call binding the contract method 0x8c1aa205.
+//
+// Solidity: function sign(address signer, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_Vm *VmSession) Sign0(signer common.Address, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _Vm.Contract.Sign0(&_Vm.CallOpts, signer, digest)
+}
+
+// Sign0 is a free data retrieval call binding the contract method 0x8c1aa205.
+//
+// Solidity: function sign(address signer, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_Vm *VmCallerSession) Sign0(signer common.Address, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _Vm.Contract.Sign0(&_Vm.CallOpts, signer, digest)
+}
+
+// Sign2 is a free data retrieval call binding the contract method 0xe341eaa4.
+//
+// Solidity: function sign(uint256 privateKey, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_Vm *VmCaller) Sign2(opts *bind.CallOpts, privateKey *big.Int, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "sign2", privateKey, digest)
+
+	outstruct := new(struct {
+		V uint8
+		R [32]byte
+		S [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.V = *abi.ConvertType(out[0], new(uint8)).(*uint8)
+	outstruct.R = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+	outstruct.S = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// Sign2 is a free data retrieval call binding the contract method 0xe341eaa4.
+//
+// Solidity: function sign(uint256 privateKey, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_Vm *VmSession) Sign2(privateKey *big.Int, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _Vm.Contract.Sign2(&_Vm.CallOpts, privateKey, digest)
+}
+
+// Sign2 is a free data retrieval call binding the contract method 0xe341eaa4.
+//
+// Solidity: function sign(uint256 privateKey, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_Vm *VmCallerSession) Sign2(privateKey *big.Int, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _Vm.Contract.Sign2(&_Vm.CallOpts, privateKey, digest)
+}
+
+// SignCompact0 is a free data retrieval call binding the contract method 0x8e2f97bf.
+//
+// Solidity: function signCompact(address signer, bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_Vm *VmCaller) SignCompact0(opts *bind.CallOpts, signer common.Address, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "signCompact0", signer, digest)
+
+	outstruct := new(struct {
+		R  [32]byte
+		Vs [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.R = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+	outstruct.Vs = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// SignCompact0 is a free data retrieval call binding the contract method 0x8e2f97bf.
+//
+// Solidity: function signCompact(address signer, bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_Vm *VmSession) SignCompact0(signer common.Address, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	return _Vm.Contract.SignCompact0(&_Vm.CallOpts, signer, digest)
+}
+
+// SignCompact0 is a free data retrieval call binding the contract method 0x8e2f97bf.
+//
+// Solidity: function signCompact(address signer, bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_Vm *VmCallerSession) SignCompact0(signer common.Address, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	return _Vm.Contract.SignCompact0(&_Vm.CallOpts, signer, digest)
+}
+
+// SignCompact1 is a free data retrieval call binding the contract method 0xa282dc4b.
+//
+// Solidity: function signCompact(bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_Vm *VmCaller) SignCompact1(opts *bind.CallOpts, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "signCompact1", digest)
+
+	outstruct := new(struct {
+		R  [32]byte
+		Vs [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.R = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+	outstruct.Vs = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// SignCompact1 is a free data retrieval call binding the contract method 0xa282dc4b.
+//
+// Solidity: function signCompact(bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_Vm *VmSession) SignCompact1(digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	return _Vm.Contract.SignCompact1(&_Vm.CallOpts, digest)
+}
+
+// SignCompact1 is a free data retrieval call binding the contract method 0xa282dc4b.
+//
+// Solidity: function signCompact(bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_Vm *VmCallerSession) SignCompact1(digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	return _Vm.Contract.SignCompact1(&_Vm.CallOpts, digest)
+}
+
+// SignCompact2 is a free data retrieval call binding the contract method 0xcc2a781f.
+//
+// Solidity: function signCompact(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_Vm *VmCaller) SignCompact2(opts *bind.CallOpts, privateKey *big.Int, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "signCompact2", privateKey, digest)
+
+	outstruct := new(struct {
+		R  [32]byte
+		Vs [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.R = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+	outstruct.Vs = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// SignCompact2 is a free data retrieval call binding the contract method 0xcc2a781f.
+//
+// Solidity: function signCompact(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_Vm *VmSession) SignCompact2(privateKey *big.Int, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	return _Vm.Contract.SignCompact2(&_Vm.CallOpts, privateKey, digest)
+}
+
+// SignCompact2 is a free data retrieval call binding the contract method 0xcc2a781f.
+//
+// Solidity: function signCompact(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_Vm *VmCallerSession) SignCompact2(privateKey *big.Int, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	return _Vm.Contract.SignCompact2(&_Vm.CallOpts, privateKey, digest)
+}
+
+// SignP256 is a free data retrieval call binding the contract method 0x83211b40.
+//
+// Solidity: function signP256(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 s)
+func (_Vm *VmCaller) SignP256(opts *bind.CallOpts, privateKey *big.Int, digest [32]byte) (struct {
+	R [32]byte
+	S [32]byte
+}, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "signP256", privateKey, digest)
+
+	outstruct := new(struct {
+		R [32]byte
+		S [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.R = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+	outstruct.S = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// SignP256 is a free data retrieval call binding the contract method 0x83211b40.
+//
+// Solidity: function signP256(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 s)
+func (_Vm *VmSession) SignP256(privateKey *big.Int, digest [32]byte) (struct {
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _Vm.Contract.SignP256(&_Vm.CallOpts, privateKey, digest)
+}
+
+// SignP256 is a free data retrieval call binding the contract method 0x83211b40.
+//
+// Solidity: function signP256(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 s)
+func (_Vm *VmCallerSession) SignP256(privateKey *big.Int, digest [32]byte) (struct {
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _Vm.Contract.SignP256(&_Vm.CallOpts, privateKey, digest)
+}
+
+// Split is a free data retrieval call binding the contract method 0x8bb75533.
+//
+// Solidity: function split(string input, string delimiter) pure returns(string[] outputs)
+func (_Vm *VmCaller) Split(opts *bind.CallOpts, input string, delimiter string) ([]string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "split", input, delimiter)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// Split is a free data retrieval call binding the contract method 0x8bb75533.
+//
+// Solidity: function split(string input, string delimiter) pure returns(string[] outputs)
+func (_Vm *VmSession) Split(input string, delimiter string) ([]string, error) {
+	return _Vm.Contract.Split(&_Vm.CallOpts, input, delimiter)
+}
+
+// Split is a free data retrieval call binding the contract method 0x8bb75533.
+//
+// Solidity: function split(string input, string delimiter) pure returns(string[] outputs)
+func (_Vm *VmCallerSession) Split(input string, delimiter string) ([]string, error) {
+	return _Vm.Contract.Split(&_Vm.CallOpts, input, delimiter)
+}
+
+// ToBase64 is a free data retrieval call binding the contract method 0x3f8be2c8.
+//
+// Solidity: function toBase64(string data) pure returns(string)
+func (_Vm *VmCaller) ToBase64(opts *bind.CallOpts, data string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "toBase64", data)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToBase64 is a free data retrieval call binding the contract method 0x3f8be2c8.
+//
+// Solidity: function toBase64(string data) pure returns(string)
+func (_Vm *VmSession) ToBase64(data string) (string, error) {
+	return _Vm.Contract.ToBase64(&_Vm.CallOpts, data)
+}
+
+// ToBase64 is a free data retrieval call binding the contract method 0x3f8be2c8.
+//
+// Solidity: function toBase64(string data) pure returns(string)
+func (_Vm *VmCallerSession) ToBase64(data string) (string, error) {
+	return _Vm.Contract.ToBase64(&_Vm.CallOpts, data)
+}
+
+// ToBase640 is a free data retrieval call binding the contract method 0xa5cbfe65.
+//
+// Solidity: function toBase64(bytes data) pure returns(string)
+func (_Vm *VmCaller) ToBase640(opts *bind.CallOpts, data []byte) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "toBase640", data)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToBase640 is a free data retrieval call binding the contract method 0xa5cbfe65.
+//
+// Solidity: function toBase64(bytes data) pure returns(string)
+func (_Vm *VmSession) ToBase640(data []byte) (string, error) {
+	return _Vm.Contract.ToBase640(&_Vm.CallOpts, data)
+}
+
+// ToBase640 is a free data retrieval call binding the contract method 0xa5cbfe65.
+//
+// Solidity: function toBase64(bytes data) pure returns(string)
+func (_Vm *VmCallerSession) ToBase640(data []byte) (string, error) {
+	return _Vm.Contract.ToBase640(&_Vm.CallOpts, data)
+}
+
+// ToBase64URL is a free data retrieval call binding the contract method 0xae3165b3.
+//
+// Solidity: function toBase64URL(string data) pure returns(string)
+func (_Vm *VmCaller) ToBase64URL(opts *bind.CallOpts, data string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "toBase64URL", data)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToBase64URL is a free data retrieval call binding the contract method 0xae3165b3.
+//
+// Solidity: function toBase64URL(string data) pure returns(string)
+func (_Vm *VmSession) ToBase64URL(data string) (string, error) {
+	return _Vm.Contract.ToBase64URL(&_Vm.CallOpts, data)
+}
+
+// ToBase64URL is a free data retrieval call binding the contract method 0xae3165b3.
+//
+// Solidity: function toBase64URL(string data) pure returns(string)
+func (_Vm *VmCallerSession) ToBase64URL(data string) (string, error) {
+	return _Vm.Contract.ToBase64URL(&_Vm.CallOpts, data)
+}
+
+// ToBase64URL0 is a free data retrieval call binding the contract method 0xc8bd0e4a.
+//
+// Solidity: function toBase64URL(bytes data) pure returns(string)
+func (_Vm *VmCaller) ToBase64URL0(opts *bind.CallOpts, data []byte) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "toBase64URL0", data)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToBase64URL0 is a free data retrieval call binding the contract method 0xc8bd0e4a.
+//
+// Solidity: function toBase64URL(bytes data) pure returns(string)
+func (_Vm *VmSession) ToBase64URL0(data []byte) (string, error) {
+	return _Vm.Contract.ToBase64URL0(&_Vm.CallOpts, data)
+}
+
+// ToBase64URL0 is a free data retrieval call binding the contract method 0xc8bd0e4a.
+//
+// Solidity: function toBase64URL(bytes data) pure returns(string)
+func (_Vm *VmCallerSession) ToBase64URL0(data []byte) (string, error) {
+	return _Vm.Contract.ToBase64URL0(&_Vm.CallOpts, data)
+}
+
+// ToLowercase is a free data retrieval call binding the contract method 0x50bb0884.
+//
+// Solidity: function toLowercase(string input) pure returns(string output)
+func (_Vm *VmCaller) ToLowercase(opts *bind.CallOpts, input string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "toLowercase", input)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToLowercase is a free data retrieval call binding the contract method 0x50bb0884.
+//
+// Solidity: function toLowercase(string input) pure returns(string output)
+func (_Vm *VmSession) ToLowercase(input string) (string, error) {
+	return _Vm.Contract.ToLowercase(&_Vm.CallOpts, input)
+}
+
+// ToLowercase is a free data retrieval call binding the contract method 0x50bb0884.
+//
+// Solidity: function toLowercase(string input) pure returns(string output)
+func (_Vm *VmCallerSession) ToLowercase(input string) (string, error) {
+	return _Vm.Contract.ToLowercase(&_Vm.CallOpts, input)
+}
+
+// ToString is a free data retrieval call binding the contract method 0x56ca623e.
+//
+// Solidity: function toString(address value) pure returns(string stringifiedValue)
+func (_Vm *VmCaller) ToString(opts *bind.CallOpts, value common.Address) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "toString", value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToString is a free data retrieval call binding the contract method 0x56ca623e.
+//
+// Solidity: function toString(address value) pure returns(string stringifiedValue)
+func (_Vm *VmSession) ToString(value common.Address) (string, error) {
+	return _Vm.Contract.ToString(&_Vm.CallOpts, value)
+}
+
+// ToString is a free data retrieval call binding the contract method 0x56ca623e.
+//
+// Solidity: function toString(address value) pure returns(string stringifiedValue)
+func (_Vm *VmCallerSession) ToString(value common.Address) (string, error) {
+	return _Vm.Contract.ToString(&_Vm.CallOpts, value)
+}
+
+// ToString0 is a free data retrieval call binding the contract method 0x6900a3ae.
+//
+// Solidity: function toString(uint256 value) pure returns(string stringifiedValue)
+func (_Vm *VmCaller) ToString0(opts *bind.CallOpts, value *big.Int) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "toString0", value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToString0 is a free data retrieval call binding the contract method 0x6900a3ae.
+//
+// Solidity: function toString(uint256 value) pure returns(string stringifiedValue)
+func (_Vm *VmSession) ToString0(value *big.Int) (string, error) {
+	return _Vm.Contract.ToString0(&_Vm.CallOpts, value)
+}
+
+// ToString0 is a free data retrieval call binding the contract method 0x6900a3ae.
+//
+// Solidity: function toString(uint256 value) pure returns(string stringifiedValue)
+func (_Vm *VmCallerSession) ToString0(value *big.Int) (string, error) {
+	return _Vm.Contract.ToString0(&_Vm.CallOpts, value)
+}
+
+// ToString1 is a free data retrieval call binding the contract method 0x71aad10d.
+//
+// Solidity: function toString(bytes value) pure returns(string stringifiedValue)
+func (_Vm *VmCaller) ToString1(opts *bind.CallOpts, value []byte) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "toString1", value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToString1 is a free data retrieval call binding the contract method 0x71aad10d.
+//
+// Solidity: function toString(bytes value) pure returns(string stringifiedValue)
+func (_Vm *VmSession) ToString1(value []byte) (string, error) {
+	return _Vm.Contract.ToString1(&_Vm.CallOpts, value)
+}
+
+// ToString1 is a free data retrieval call binding the contract method 0x71aad10d.
+//
+// Solidity: function toString(bytes value) pure returns(string stringifiedValue)
+func (_Vm *VmCallerSession) ToString1(value []byte) (string, error) {
+	return _Vm.Contract.ToString1(&_Vm.CallOpts, value)
+}
+
+// ToString2 is a free data retrieval call binding the contract method 0x71dce7da.
+//
+// Solidity: function toString(bool value) pure returns(string stringifiedValue)
+func (_Vm *VmCaller) ToString2(opts *bind.CallOpts, value bool) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "toString2", value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToString2 is a free data retrieval call binding the contract method 0x71dce7da.
+//
+// Solidity: function toString(bool value) pure returns(string stringifiedValue)
+func (_Vm *VmSession) ToString2(value bool) (string, error) {
+	return _Vm.Contract.ToString2(&_Vm.CallOpts, value)
+}
+
+// ToString2 is a free data retrieval call binding the contract method 0x71dce7da.
+//
+// Solidity: function toString(bool value) pure returns(string stringifiedValue)
+func (_Vm *VmCallerSession) ToString2(value bool) (string, error) {
+	return _Vm.Contract.ToString2(&_Vm.CallOpts, value)
+}
+
+// ToString3 is a free data retrieval call binding the contract method 0xa322c40e.
+//
+// Solidity: function toString(int256 value) pure returns(string stringifiedValue)
+func (_Vm *VmCaller) ToString3(opts *bind.CallOpts, value *big.Int) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "toString3", value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToString3 is a free data retrieval call binding the contract method 0xa322c40e.
+//
+// Solidity: function toString(int256 value) pure returns(string stringifiedValue)
+func (_Vm *VmSession) ToString3(value *big.Int) (string, error) {
+	return _Vm.Contract.ToString3(&_Vm.CallOpts, value)
+}
+
+// ToString3 is a free data retrieval call binding the contract method 0xa322c40e.
+//
+// Solidity: function toString(int256 value) pure returns(string stringifiedValue)
+func (_Vm *VmCallerSession) ToString3(value *big.Int) (string, error) {
+	return _Vm.Contract.ToString3(&_Vm.CallOpts, value)
+}
+
+// ToString4 is a free data retrieval call binding the contract method 0xb11a19e8.
+//
+// Solidity: function toString(bytes32 value) pure returns(string stringifiedValue)
+func (_Vm *VmCaller) ToString4(opts *bind.CallOpts, value [32]byte) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "toString4", value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToString4 is a free data retrieval call binding the contract method 0xb11a19e8.
+//
+// Solidity: function toString(bytes32 value) pure returns(string stringifiedValue)
+func (_Vm *VmSession) ToString4(value [32]byte) (string, error) {
+	return _Vm.Contract.ToString4(&_Vm.CallOpts, value)
+}
+
+// ToString4 is a free data retrieval call binding the contract method 0xb11a19e8.
+//
+// Solidity: function toString(bytes32 value) pure returns(string stringifiedValue)
+func (_Vm *VmCallerSession) ToString4(value [32]byte) (string, error) {
+	return _Vm.Contract.ToString4(&_Vm.CallOpts, value)
+}
+
+// ToUppercase is a free data retrieval call binding the contract method 0x074ae3d7.
+//
+// Solidity: function toUppercase(string input) pure returns(string output)
+func (_Vm *VmCaller) ToUppercase(opts *bind.CallOpts, input string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "toUppercase", input)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToUppercase is a free data retrieval call binding the contract method 0x074ae3d7.
+//
+// Solidity: function toUppercase(string input) pure returns(string output)
+func (_Vm *VmSession) ToUppercase(input string) (string, error) {
+	return _Vm.Contract.ToUppercase(&_Vm.CallOpts, input)
+}
+
+// ToUppercase is a free data retrieval call binding the contract method 0x074ae3d7.
+//
+// Solidity: function toUppercase(string input) pure returns(string output)
+func (_Vm *VmCallerSession) ToUppercase(input string) (string, error) {
+	return _Vm.Contract.ToUppercase(&_Vm.CallOpts, input)
+}
+
+// Trim is a free data retrieval call binding the contract method 0xb2dad155.
+//
+// Solidity: function trim(string input) pure returns(string output)
+func (_Vm *VmCaller) Trim(opts *bind.CallOpts, input string) (string, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "trim", input)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// Trim is a free data retrieval call binding the contract method 0xb2dad155.
+//
+// Solidity: function trim(string input) pure returns(string output)
+func (_Vm *VmSession) Trim(input string) (string, error) {
+	return _Vm.Contract.Trim(&_Vm.CallOpts, input)
+}
+
+// Trim is a free data retrieval call binding the contract method 0xb2dad155.
+//
+// Solidity: function trim(string input) pure returns(string output)
+func (_Vm *VmCallerSession) Trim(input string) (string, error) {
+	return _Vm.Contract.Trim(&_Vm.CallOpts, input)
+}
+
+// UnixTime is a free data retrieval call binding the contract method 0x625387dc.
+//
+// Solidity: function unixTime() view returns(uint256 milliseconds)
+func (_Vm *VmCaller) UnixTime(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _Vm.contract.Call(opts, &out, "unixTime")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// UnixTime is a free data retrieval call binding the contract method 0x625387dc.
+//
+// Solidity: function unixTime() view returns(uint256 milliseconds)
+func (_Vm *VmSession) UnixTime() (*big.Int, error) {
+	return _Vm.Contract.UnixTime(&_Vm.CallOpts)
+}
+
+// UnixTime is a free data retrieval call binding the contract method 0x625387dc.
+//
+// Solidity: function unixTime() view returns(uint256 milliseconds)
+func (_Vm *VmCallerSession) UnixTime() (*big.Int, error) {
+	return _Vm.Contract.UnixTime(&_Vm.CallOpts)
+}
+
+// AccessList is a paid mutator transaction binding the contract method 0x743e4cb7.
+//
+// Solidity: function accessList((address,bytes32[])[] access) returns()
+func (_Vm *VmTransactor) AccessList(opts *bind.TransactOpts, access []VmSafeAccessListItem) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "accessList", access)
+}
+
+// AccessList is a paid mutator transaction binding the contract method 0x743e4cb7.
+//
+// Solidity: function accessList((address,bytes32[])[] access) returns()
+func (_Vm *VmSession) AccessList(access []VmSafeAccessListItem) (*types.Transaction, error) {
+	return _Vm.Contract.AccessList(&_Vm.TransactOpts, access)
+}
+
+// AccessList is a paid mutator transaction binding the contract method 0x743e4cb7.
+//
+// Solidity: function accessList((address,bytes32[])[] access) returns()
+func (_Vm *VmTransactorSession) AccessList(access []VmSafeAccessListItem) (*types.Transaction, error) {
+	return _Vm.Contract.AccessList(&_Vm.TransactOpts, access)
+}
+
+// Accesses is a paid mutator transaction binding the contract method 0x65bc9481.
+//
+// Solidity: function accesses(address target) returns(bytes32[] readSlots, bytes32[] writeSlots)
+func (_Vm *VmTransactor) Accesses(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "accesses", target)
+}
+
+// Accesses is a paid mutator transaction binding the contract method 0x65bc9481.
+//
+// Solidity: function accesses(address target) returns(bytes32[] readSlots, bytes32[] writeSlots)
+func (_Vm *VmSession) Accesses(target common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.Accesses(&_Vm.TransactOpts, target)
+}
+
+// Accesses is a paid mutator transaction binding the contract method 0x65bc9481.
+//
+// Solidity: function accesses(address target) returns(bytes32[] readSlots, bytes32[] writeSlots)
+func (_Vm *VmTransactorSession) Accesses(target common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.Accesses(&_Vm.TransactOpts, target)
+}
+
+// AllowCheatcodes is a paid mutator transaction binding the contract method 0xea060291.
+//
+// Solidity: function allowCheatcodes(address account) returns()
+func (_Vm *VmTransactor) AllowCheatcodes(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "allowCheatcodes", account)
+}
+
+// AllowCheatcodes is a paid mutator transaction binding the contract method 0xea060291.
+//
+// Solidity: function allowCheatcodes(address account) returns()
+func (_Vm *VmSession) AllowCheatcodes(account common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.AllowCheatcodes(&_Vm.TransactOpts, account)
+}
+
+// AllowCheatcodes is a paid mutator transaction binding the contract method 0xea060291.
+//
+// Solidity: function allowCheatcodes(address account) returns()
+func (_Vm *VmTransactorSession) AllowCheatcodes(account common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.AllowCheatcodes(&_Vm.TransactOpts, account)
+}
+
+// AttachDelegation is a paid mutator transaction binding the contract method 0x14ae3519.
+//
+// Solidity: function attachDelegation((uint8,bytes32,bytes32,uint64,address) signedDelegation) returns()
+func (_Vm *VmTransactor) AttachDelegation(opts *bind.TransactOpts, signedDelegation VmSafeSignedDelegation) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "attachDelegation", signedDelegation)
+}
+
+// AttachDelegation is a paid mutator transaction binding the contract method 0x14ae3519.
+//
+// Solidity: function attachDelegation((uint8,bytes32,bytes32,uint64,address) signedDelegation) returns()
+func (_Vm *VmSession) AttachDelegation(signedDelegation VmSafeSignedDelegation) (*types.Transaction, error) {
+	return _Vm.Contract.AttachDelegation(&_Vm.TransactOpts, signedDelegation)
+}
+
+// AttachDelegation is a paid mutator transaction binding the contract method 0x14ae3519.
+//
+// Solidity: function attachDelegation((uint8,bytes32,bytes32,uint64,address) signedDelegation) returns()
+func (_Vm *VmTransactorSession) AttachDelegation(signedDelegation VmSafeSignedDelegation) (*types.Transaction, error) {
+	return _Vm.Contract.AttachDelegation(&_Vm.TransactOpts, signedDelegation)
+}
+
+// BlobBaseFee is a paid mutator transaction binding the contract method 0x6d315d7e.
+//
+// Solidity: function blobBaseFee(uint256 newBlobBaseFee) returns()
+func (_Vm *VmTransactor) BlobBaseFee(opts *bind.TransactOpts, newBlobBaseFee *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "blobBaseFee", newBlobBaseFee)
+}
+
+// BlobBaseFee is a paid mutator transaction binding the contract method 0x6d315d7e.
+//
+// Solidity: function blobBaseFee(uint256 newBlobBaseFee) returns()
+func (_Vm *VmSession) BlobBaseFee(newBlobBaseFee *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.BlobBaseFee(&_Vm.TransactOpts, newBlobBaseFee)
+}
+
+// BlobBaseFee is a paid mutator transaction binding the contract method 0x6d315d7e.
+//
+// Solidity: function blobBaseFee(uint256 newBlobBaseFee) returns()
+func (_Vm *VmTransactorSession) BlobBaseFee(newBlobBaseFee *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.BlobBaseFee(&_Vm.TransactOpts, newBlobBaseFee)
+}
+
+// Blobhashes is a paid mutator transaction binding the contract method 0x129de7eb.
+//
+// Solidity: function blobhashes(bytes32[] hashes) returns()
+func (_Vm *VmTransactor) Blobhashes(opts *bind.TransactOpts, hashes [][32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "blobhashes", hashes)
+}
+
+// Blobhashes is a paid mutator transaction binding the contract method 0x129de7eb.
+//
+// Solidity: function blobhashes(bytes32[] hashes) returns()
+func (_Vm *VmSession) Blobhashes(hashes [][32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.Blobhashes(&_Vm.TransactOpts, hashes)
+}
+
+// Blobhashes is a paid mutator transaction binding the contract method 0x129de7eb.
+//
+// Solidity: function blobhashes(bytes32[] hashes) returns()
+func (_Vm *VmTransactorSession) Blobhashes(hashes [][32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.Blobhashes(&_Vm.TransactOpts, hashes)
+}
+
+// Broadcast is a paid mutator transaction binding the contract method 0xafc98040.
+//
+// Solidity: function broadcast() returns()
+func (_Vm *VmTransactor) Broadcast(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "broadcast")
+}
+
+// Broadcast is a paid mutator transaction binding the contract method 0xafc98040.
+//
+// Solidity: function broadcast() returns()
+func (_Vm *VmSession) Broadcast() (*types.Transaction, error) {
+	return _Vm.Contract.Broadcast(&_Vm.TransactOpts)
+}
+
+// Broadcast is a paid mutator transaction binding the contract method 0xafc98040.
+//
+// Solidity: function broadcast() returns()
+func (_Vm *VmTransactorSession) Broadcast() (*types.Transaction, error) {
+	return _Vm.Contract.Broadcast(&_Vm.TransactOpts)
+}
+
+// Broadcast0 is a paid mutator transaction binding the contract method 0xe6962cdb.
+//
+// Solidity: function broadcast(address signer) returns()
+func (_Vm *VmTransactor) Broadcast0(opts *bind.TransactOpts, signer common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "broadcast0", signer)
+}
+
+// Broadcast0 is a paid mutator transaction binding the contract method 0xe6962cdb.
+//
+// Solidity: function broadcast(address signer) returns()
+func (_Vm *VmSession) Broadcast0(signer common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.Broadcast0(&_Vm.TransactOpts, signer)
+}
+
+// Broadcast0 is a paid mutator transaction binding the contract method 0xe6962cdb.
+//
+// Solidity: function broadcast(address signer) returns()
+func (_Vm *VmTransactorSession) Broadcast0(signer common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.Broadcast0(&_Vm.TransactOpts, signer)
+}
+
+// Broadcast1 is a paid mutator transaction binding the contract method 0xf67a965b.
+//
+// Solidity: function broadcast(uint256 privateKey) returns()
+func (_Vm *VmTransactor) Broadcast1(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "broadcast1", privateKey)
+}
+
+// Broadcast1 is a paid mutator transaction binding the contract method 0xf67a965b.
+//
+// Solidity: function broadcast(uint256 privateKey) returns()
+func (_Vm *VmSession) Broadcast1(privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Broadcast1(&_Vm.TransactOpts, privateKey)
+}
+
+// Broadcast1 is a paid mutator transaction binding the contract method 0xf67a965b.
+//
+// Solidity: function broadcast(uint256 privateKey) returns()
+func (_Vm *VmTransactorSession) Broadcast1(privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Broadcast1(&_Vm.TransactOpts, privateKey)
+}
+
+// BroadcastRawTransaction is a paid mutator transaction binding the contract method 0x8c0c72e0.
+//
+// Solidity: function broadcastRawTransaction(bytes data) returns()
+func (_Vm *VmTransactor) BroadcastRawTransaction(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "broadcastRawTransaction", data)
+}
+
+// BroadcastRawTransaction is a paid mutator transaction binding the contract method 0x8c0c72e0.
+//
+// Solidity: function broadcastRawTransaction(bytes data) returns()
+func (_Vm *VmSession) BroadcastRawTransaction(data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.BroadcastRawTransaction(&_Vm.TransactOpts, data)
+}
+
+// BroadcastRawTransaction is a paid mutator transaction binding the contract method 0x8c0c72e0.
+//
+// Solidity: function broadcastRawTransaction(bytes data) returns()
+func (_Vm *VmTransactorSession) BroadcastRawTransaction(data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.BroadcastRawTransaction(&_Vm.TransactOpts, data)
+}
+
+// ChainId is a paid mutator transaction binding the contract method 0x4049ddd2.
+//
+// Solidity: function chainId(uint256 newChainId) returns()
+func (_Vm *VmTransactor) ChainId(opts *bind.TransactOpts, newChainId *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "chainId", newChainId)
+}
+
+// ChainId is a paid mutator transaction binding the contract method 0x4049ddd2.
+//
+// Solidity: function chainId(uint256 newChainId) returns()
+func (_Vm *VmSession) ChainId(newChainId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.ChainId(&_Vm.TransactOpts, newChainId)
+}
+
+// ChainId is a paid mutator transaction binding the contract method 0x4049ddd2.
+//
+// Solidity: function chainId(uint256 newChainId) returns()
+func (_Vm *VmTransactorSession) ChainId(newChainId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.ChainId(&_Vm.TransactOpts, newChainId)
+}
+
+// ClearMockedCalls is a paid mutator transaction binding the contract method 0x3fdf4e15.
+//
+// Solidity: function clearMockedCalls() returns()
+func (_Vm *VmTransactor) ClearMockedCalls(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "clearMockedCalls")
+}
+
+// ClearMockedCalls is a paid mutator transaction binding the contract method 0x3fdf4e15.
+//
+// Solidity: function clearMockedCalls() returns()
+func (_Vm *VmSession) ClearMockedCalls() (*types.Transaction, error) {
+	return _Vm.Contract.ClearMockedCalls(&_Vm.TransactOpts)
+}
+
+// ClearMockedCalls is a paid mutator transaction binding the contract method 0x3fdf4e15.
+//
+// Solidity: function clearMockedCalls() returns()
+func (_Vm *VmTransactorSession) ClearMockedCalls() (*types.Transaction, error) {
+	return _Vm.Contract.ClearMockedCalls(&_Vm.TransactOpts)
+}
+
+// CloneAccount is a paid mutator transaction binding the contract method 0x533d61c9.
+//
+// Solidity: function cloneAccount(address source, address target) returns()
+func (_Vm *VmTransactor) CloneAccount(opts *bind.TransactOpts, source common.Address, target common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "cloneAccount", source, target)
+}
+
+// CloneAccount is a paid mutator transaction binding the contract method 0x533d61c9.
+//
+// Solidity: function cloneAccount(address source, address target) returns()
+func (_Vm *VmSession) CloneAccount(source common.Address, target common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.CloneAccount(&_Vm.TransactOpts, source, target)
+}
+
+// CloneAccount is a paid mutator transaction binding the contract method 0x533d61c9.
+//
+// Solidity: function cloneAccount(address source, address target) returns()
+func (_Vm *VmTransactorSession) CloneAccount(source common.Address, target common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.CloneAccount(&_Vm.TransactOpts, source, target)
+}
+
+// CloseFile is a paid mutator transaction binding the contract method 0x48c3241f.
+//
+// Solidity: function closeFile(string path) returns()
+func (_Vm *VmTransactor) CloseFile(opts *bind.TransactOpts, path string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "closeFile", path)
+}
+
+// CloseFile is a paid mutator transaction binding the contract method 0x48c3241f.
+//
+// Solidity: function closeFile(string path) returns()
+func (_Vm *VmSession) CloseFile(path string) (*types.Transaction, error) {
+	return _Vm.Contract.CloseFile(&_Vm.TransactOpts, path)
+}
+
+// CloseFile is a paid mutator transaction binding the contract method 0x48c3241f.
+//
+// Solidity: function closeFile(string path) returns()
+func (_Vm *VmTransactorSession) CloseFile(path string) (*types.Transaction, error) {
+	return _Vm.Contract.CloseFile(&_Vm.TransactOpts, path)
+}
+
+// Coinbase is a paid mutator transaction binding the contract method 0xff483c54.
+//
+// Solidity: function coinbase(address newCoinbase) returns()
+func (_Vm *VmTransactor) Coinbase(opts *bind.TransactOpts, newCoinbase common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "coinbase", newCoinbase)
+}
+
+// Coinbase is a paid mutator transaction binding the contract method 0xff483c54.
+//
+// Solidity: function coinbase(address newCoinbase) returns()
+func (_Vm *VmSession) Coinbase(newCoinbase common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.Coinbase(&_Vm.TransactOpts, newCoinbase)
+}
+
+// Coinbase is a paid mutator transaction binding the contract method 0xff483c54.
+//
+// Solidity: function coinbase(address newCoinbase) returns()
+func (_Vm *VmTransactorSession) Coinbase(newCoinbase common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.Coinbase(&_Vm.TransactOpts, newCoinbase)
+}
+
+// Contains is a paid mutator transaction binding the contract method 0x3fb18aec.
+//
+// Solidity: function contains(string subject, string search) returns(bool result)
+func (_Vm *VmTransactor) Contains(opts *bind.TransactOpts, subject string, search string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "contains", subject, search)
+}
+
+// Contains is a paid mutator transaction binding the contract method 0x3fb18aec.
+//
+// Solidity: function contains(string subject, string search) returns(bool result)
+func (_Vm *VmSession) Contains(subject string, search string) (*types.Transaction, error) {
+	return _Vm.Contract.Contains(&_Vm.TransactOpts, subject, search)
+}
+
+// Contains is a paid mutator transaction binding the contract method 0x3fb18aec.
+//
+// Solidity: function contains(string subject, string search) returns(bool result)
+func (_Vm *VmTransactorSession) Contains(subject string, search string) (*types.Transaction, error) {
+	return _Vm.Contract.Contains(&_Vm.TransactOpts, subject, search)
+}
+
+// Cool is a paid mutator transaction binding the contract method 0x40ff9f21.
+//
+// Solidity: function cool(address target) returns()
+func (_Vm *VmTransactor) Cool(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "cool", target)
+}
+
+// Cool is a paid mutator transaction binding the contract method 0x40ff9f21.
+//
+// Solidity: function cool(address target) returns()
+func (_Vm *VmSession) Cool(target common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.Cool(&_Vm.TransactOpts, target)
+}
+
+// Cool is a paid mutator transaction binding the contract method 0x40ff9f21.
+//
+// Solidity: function cool(address target) returns()
+func (_Vm *VmTransactorSession) Cool(target common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.Cool(&_Vm.TransactOpts, target)
+}
+
+// CoolSlot is a paid mutator transaction binding the contract method 0x8c78e654.
+//
+// Solidity: function coolSlot(address target, bytes32 slot) returns()
+func (_Vm *VmTransactor) CoolSlot(opts *bind.TransactOpts, target common.Address, slot [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "coolSlot", target, slot)
+}
+
+// CoolSlot is a paid mutator transaction binding the contract method 0x8c78e654.
+//
+// Solidity: function coolSlot(address target, bytes32 slot) returns()
+func (_Vm *VmSession) CoolSlot(target common.Address, slot [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.CoolSlot(&_Vm.TransactOpts, target, slot)
+}
+
+// CoolSlot is a paid mutator transaction binding the contract method 0x8c78e654.
+//
+// Solidity: function coolSlot(address target, bytes32 slot) returns()
+func (_Vm *VmTransactorSession) CoolSlot(target common.Address, slot [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.CoolSlot(&_Vm.TransactOpts, target, slot)
+}
+
+// CopyFile is a paid mutator transaction binding the contract method 0xa54a87d8.
+//
+// Solidity: function copyFile(string from, string to) returns(uint64 copied)
+func (_Vm *VmTransactor) CopyFile(opts *bind.TransactOpts, from string, to string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "copyFile", from, to)
+}
+
+// CopyFile is a paid mutator transaction binding the contract method 0xa54a87d8.
+//
+// Solidity: function copyFile(string from, string to) returns(uint64 copied)
+func (_Vm *VmSession) CopyFile(from string, to string) (*types.Transaction, error) {
+	return _Vm.Contract.CopyFile(&_Vm.TransactOpts, from, to)
+}
+
+// CopyFile is a paid mutator transaction binding the contract method 0xa54a87d8.
+//
+// Solidity: function copyFile(string from, string to) returns(uint64 copied)
+func (_Vm *VmTransactorSession) CopyFile(from string, to string) (*types.Transaction, error) {
+	return _Vm.Contract.CopyFile(&_Vm.TransactOpts, from, to)
+}
+
+// CopyStorage is a paid mutator transaction binding the contract method 0x203dac0d.
+//
+// Solidity: function copyStorage(address from, address to) returns()
+func (_Vm *VmTransactor) CopyStorage(opts *bind.TransactOpts, from common.Address, to common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "copyStorage", from, to)
+}
+
+// CopyStorage is a paid mutator transaction binding the contract method 0x203dac0d.
+//
+// Solidity: function copyStorage(address from, address to) returns()
+func (_Vm *VmSession) CopyStorage(from common.Address, to common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.CopyStorage(&_Vm.TransactOpts, from, to)
+}
+
+// CopyStorage is a paid mutator transaction binding the contract method 0x203dac0d.
+//
+// Solidity: function copyStorage(address from, address to) returns()
+func (_Vm *VmTransactorSession) CopyStorage(from common.Address, to common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.CopyStorage(&_Vm.TransactOpts, from, to)
+}
+
+// CreateDir is a paid mutator transaction binding the contract method 0x168b64d3.
+//
+// Solidity: function createDir(string path, bool recursive) returns()
+func (_Vm *VmTransactor) CreateDir(opts *bind.TransactOpts, path string, recursive bool) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "createDir", path, recursive)
+}
+
+// CreateDir is a paid mutator transaction binding the contract method 0x168b64d3.
+//
+// Solidity: function createDir(string path, bool recursive) returns()
+func (_Vm *VmSession) CreateDir(path string, recursive bool) (*types.Transaction, error) {
+	return _Vm.Contract.CreateDir(&_Vm.TransactOpts, path, recursive)
+}
+
+// CreateDir is a paid mutator transaction binding the contract method 0x168b64d3.
+//
+// Solidity: function createDir(string path, bool recursive) returns()
+func (_Vm *VmTransactorSession) CreateDir(path string, recursive bool) (*types.Transaction, error) {
+	return _Vm.Contract.CreateDir(&_Vm.TransactOpts, path, recursive)
+}
+
+// CreateFork is a paid mutator transaction binding the contract method 0x31ba3498.
+//
+// Solidity: function createFork(string urlOrAlias) returns(uint256 forkId)
+func (_Vm *VmTransactor) CreateFork(opts *bind.TransactOpts, urlOrAlias string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "createFork", urlOrAlias)
+}
+
+// CreateFork is a paid mutator transaction binding the contract method 0x31ba3498.
+//
+// Solidity: function createFork(string urlOrAlias) returns(uint256 forkId)
+func (_Vm *VmSession) CreateFork(urlOrAlias string) (*types.Transaction, error) {
+	return _Vm.Contract.CreateFork(&_Vm.TransactOpts, urlOrAlias)
+}
+
+// CreateFork is a paid mutator transaction binding the contract method 0x31ba3498.
+//
+// Solidity: function createFork(string urlOrAlias) returns(uint256 forkId)
+func (_Vm *VmTransactorSession) CreateFork(urlOrAlias string) (*types.Transaction, error) {
+	return _Vm.Contract.CreateFork(&_Vm.TransactOpts, urlOrAlias)
+}
+
+// CreateFork0 is a paid mutator transaction binding the contract method 0x6ba3ba2b.
+//
+// Solidity: function createFork(string urlOrAlias, uint256 blockNumber) returns(uint256 forkId)
+func (_Vm *VmTransactor) CreateFork0(opts *bind.TransactOpts, urlOrAlias string, blockNumber *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "createFork0", urlOrAlias, blockNumber)
+}
+
+// CreateFork0 is a paid mutator transaction binding the contract method 0x6ba3ba2b.
+//
+// Solidity: function createFork(string urlOrAlias, uint256 blockNumber) returns(uint256 forkId)
+func (_Vm *VmSession) CreateFork0(urlOrAlias string, blockNumber *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.CreateFork0(&_Vm.TransactOpts, urlOrAlias, blockNumber)
+}
+
+// CreateFork0 is a paid mutator transaction binding the contract method 0x6ba3ba2b.
+//
+// Solidity: function createFork(string urlOrAlias, uint256 blockNumber) returns(uint256 forkId)
+func (_Vm *VmTransactorSession) CreateFork0(urlOrAlias string, blockNumber *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.CreateFork0(&_Vm.TransactOpts, urlOrAlias, blockNumber)
+}
+
+// CreateFork1 is a paid mutator transaction binding the contract method 0x7ca29682.
+//
+// Solidity: function createFork(string urlOrAlias, bytes32 txHash) returns(uint256 forkId)
+func (_Vm *VmTransactor) CreateFork1(opts *bind.TransactOpts, urlOrAlias string, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "createFork1", urlOrAlias, txHash)
+}
+
+// CreateFork1 is a paid mutator transaction binding the contract method 0x7ca29682.
+//
+// Solidity: function createFork(string urlOrAlias, bytes32 txHash) returns(uint256 forkId)
+func (_Vm *VmSession) CreateFork1(urlOrAlias string, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.CreateFork1(&_Vm.TransactOpts, urlOrAlias, txHash)
+}
+
+// CreateFork1 is a paid mutator transaction binding the contract method 0x7ca29682.
+//
+// Solidity: function createFork(string urlOrAlias, bytes32 txHash) returns(uint256 forkId)
+func (_Vm *VmTransactorSession) CreateFork1(urlOrAlias string, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.CreateFork1(&_Vm.TransactOpts, urlOrAlias, txHash)
+}
+
+// CreateSelectFork is a paid mutator transaction binding the contract method 0x71ee464d.
+//
+// Solidity: function createSelectFork(string urlOrAlias, uint256 blockNumber) returns(uint256 forkId)
+func (_Vm *VmTransactor) CreateSelectFork(opts *bind.TransactOpts, urlOrAlias string, blockNumber *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "createSelectFork", urlOrAlias, blockNumber)
+}
+
+// CreateSelectFork is a paid mutator transaction binding the contract method 0x71ee464d.
+//
+// Solidity: function createSelectFork(string urlOrAlias, uint256 blockNumber) returns(uint256 forkId)
+func (_Vm *VmSession) CreateSelectFork(urlOrAlias string, blockNumber *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.CreateSelectFork(&_Vm.TransactOpts, urlOrAlias, blockNumber)
+}
+
+// CreateSelectFork is a paid mutator transaction binding the contract method 0x71ee464d.
+//
+// Solidity: function createSelectFork(string urlOrAlias, uint256 blockNumber) returns(uint256 forkId)
+func (_Vm *VmTransactorSession) CreateSelectFork(urlOrAlias string, blockNumber *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.CreateSelectFork(&_Vm.TransactOpts, urlOrAlias, blockNumber)
+}
+
+// CreateSelectFork0 is a paid mutator transaction binding the contract method 0x84d52b7a.
+//
+// Solidity: function createSelectFork(string urlOrAlias, bytes32 txHash) returns(uint256 forkId)
+func (_Vm *VmTransactor) CreateSelectFork0(opts *bind.TransactOpts, urlOrAlias string, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "createSelectFork0", urlOrAlias, txHash)
+}
+
+// CreateSelectFork0 is a paid mutator transaction binding the contract method 0x84d52b7a.
+//
+// Solidity: function createSelectFork(string urlOrAlias, bytes32 txHash) returns(uint256 forkId)
+func (_Vm *VmSession) CreateSelectFork0(urlOrAlias string, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.CreateSelectFork0(&_Vm.TransactOpts, urlOrAlias, txHash)
+}
+
+// CreateSelectFork0 is a paid mutator transaction binding the contract method 0x84d52b7a.
+//
+// Solidity: function createSelectFork(string urlOrAlias, bytes32 txHash) returns(uint256 forkId)
+func (_Vm *VmTransactorSession) CreateSelectFork0(urlOrAlias string, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.CreateSelectFork0(&_Vm.TransactOpts, urlOrAlias, txHash)
+}
+
+// CreateSelectFork1 is a paid mutator transaction binding the contract method 0x98680034.
+//
+// Solidity: function createSelectFork(string urlOrAlias) returns(uint256 forkId)
+func (_Vm *VmTransactor) CreateSelectFork1(opts *bind.TransactOpts, urlOrAlias string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "createSelectFork1", urlOrAlias)
+}
+
+// CreateSelectFork1 is a paid mutator transaction binding the contract method 0x98680034.
+//
+// Solidity: function createSelectFork(string urlOrAlias) returns(uint256 forkId)
+func (_Vm *VmSession) CreateSelectFork1(urlOrAlias string) (*types.Transaction, error) {
+	return _Vm.Contract.CreateSelectFork1(&_Vm.TransactOpts, urlOrAlias)
+}
+
+// CreateSelectFork1 is a paid mutator transaction binding the contract method 0x98680034.
+//
+// Solidity: function createSelectFork(string urlOrAlias) returns(uint256 forkId)
+func (_Vm *VmTransactorSession) CreateSelectFork1(urlOrAlias string) (*types.Transaction, error) {
+	return _Vm.Contract.CreateSelectFork1(&_Vm.TransactOpts, urlOrAlias)
+}
+
+// CreateWallet is a paid mutator transaction binding the contract method 0x7404f1d2.
+//
+// Solidity: function createWallet(string walletLabel) returns((address,uint256,uint256,uint256) wallet)
+func (_Vm *VmTransactor) CreateWallet(opts *bind.TransactOpts, walletLabel string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "createWallet", walletLabel)
+}
+
+// CreateWallet is a paid mutator transaction binding the contract method 0x7404f1d2.
+//
+// Solidity: function createWallet(string walletLabel) returns((address,uint256,uint256,uint256) wallet)
+func (_Vm *VmSession) CreateWallet(walletLabel string) (*types.Transaction, error) {
+	return _Vm.Contract.CreateWallet(&_Vm.TransactOpts, walletLabel)
+}
+
+// CreateWallet is a paid mutator transaction binding the contract method 0x7404f1d2.
+//
+// Solidity: function createWallet(string walletLabel) returns((address,uint256,uint256,uint256) wallet)
+func (_Vm *VmTransactorSession) CreateWallet(walletLabel string) (*types.Transaction, error) {
+	return _Vm.Contract.CreateWallet(&_Vm.TransactOpts, walletLabel)
+}
+
+// CreateWallet0 is a paid mutator transaction binding the contract method 0x7a675bb6.
+//
+// Solidity: function createWallet(uint256 privateKey) returns((address,uint256,uint256,uint256) wallet)
+func (_Vm *VmTransactor) CreateWallet0(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "createWallet0", privateKey)
+}
+
+// CreateWallet0 is a paid mutator transaction binding the contract method 0x7a675bb6.
+//
+// Solidity: function createWallet(uint256 privateKey) returns((address,uint256,uint256,uint256) wallet)
+func (_Vm *VmSession) CreateWallet0(privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.CreateWallet0(&_Vm.TransactOpts, privateKey)
+}
+
+// CreateWallet0 is a paid mutator transaction binding the contract method 0x7a675bb6.
+//
+// Solidity: function createWallet(uint256 privateKey) returns((address,uint256,uint256,uint256) wallet)
+func (_Vm *VmTransactorSession) CreateWallet0(privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.CreateWallet0(&_Vm.TransactOpts, privateKey)
+}
+
+// CreateWallet1 is a paid mutator transaction binding the contract method 0xed7c5462.
+//
+// Solidity: function createWallet(uint256 privateKey, string walletLabel) returns((address,uint256,uint256,uint256) wallet)
+func (_Vm *VmTransactor) CreateWallet1(opts *bind.TransactOpts, privateKey *big.Int, walletLabel string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "createWallet1", privateKey, walletLabel)
+}
+
+// CreateWallet1 is a paid mutator transaction binding the contract method 0xed7c5462.
+//
+// Solidity: function createWallet(uint256 privateKey, string walletLabel) returns((address,uint256,uint256,uint256) wallet)
+func (_Vm *VmSession) CreateWallet1(privateKey *big.Int, walletLabel string) (*types.Transaction, error) {
+	return _Vm.Contract.CreateWallet1(&_Vm.TransactOpts, privateKey, walletLabel)
+}
+
+// CreateWallet1 is a paid mutator transaction binding the contract method 0xed7c5462.
+//
+// Solidity: function createWallet(uint256 privateKey, string walletLabel) returns((address,uint256,uint256,uint256) wallet)
+func (_Vm *VmTransactorSession) CreateWallet1(privateKey *big.Int, walletLabel string) (*types.Transaction, error) {
+	return _Vm.Contract.CreateWallet1(&_Vm.TransactOpts, privateKey, walletLabel)
+}
+
+// Deal is a paid mutator transaction binding the contract method 0xc88a5e6d.
+//
+// Solidity: function deal(address account, uint256 newBalance) returns()
+func (_Vm *VmTransactor) Deal(opts *bind.TransactOpts, account common.Address, newBalance *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "deal", account, newBalance)
+}
+
+// Deal is a paid mutator transaction binding the contract method 0xc88a5e6d.
+//
+// Solidity: function deal(address account, uint256 newBalance) returns()
+func (_Vm *VmSession) Deal(account common.Address, newBalance *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Deal(&_Vm.TransactOpts, account, newBalance)
+}
+
+// Deal is a paid mutator transaction binding the contract method 0xc88a5e6d.
+//
+// Solidity: function deal(address account, uint256 newBalance) returns()
+func (_Vm *VmTransactorSession) Deal(account common.Address, newBalance *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Deal(&_Vm.TransactOpts, account, newBalance)
+}
+
+// DeleteSnapshot is a paid mutator transaction binding the contract method 0xa6368557.
+//
+// Solidity: function deleteSnapshot(uint256 snapshotId) returns(bool success)
+func (_Vm *VmTransactor) DeleteSnapshot(opts *bind.TransactOpts, snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "deleteSnapshot", snapshotId)
+}
+
+// DeleteSnapshot is a paid mutator transaction binding the contract method 0xa6368557.
+//
+// Solidity: function deleteSnapshot(uint256 snapshotId) returns(bool success)
+func (_Vm *VmSession) DeleteSnapshot(snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.DeleteSnapshot(&_Vm.TransactOpts, snapshotId)
+}
+
+// DeleteSnapshot is a paid mutator transaction binding the contract method 0xa6368557.
+//
+// Solidity: function deleteSnapshot(uint256 snapshotId) returns(bool success)
+func (_Vm *VmTransactorSession) DeleteSnapshot(snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.DeleteSnapshot(&_Vm.TransactOpts, snapshotId)
+}
+
+// DeleteSnapshots is a paid mutator transaction binding the contract method 0x421ae469.
+//
+// Solidity: function deleteSnapshots() returns()
+func (_Vm *VmTransactor) DeleteSnapshots(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "deleteSnapshots")
+}
+
+// DeleteSnapshots is a paid mutator transaction binding the contract method 0x421ae469.
+//
+// Solidity: function deleteSnapshots() returns()
+func (_Vm *VmSession) DeleteSnapshots() (*types.Transaction, error) {
+	return _Vm.Contract.DeleteSnapshots(&_Vm.TransactOpts)
+}
+
+// DeleteSnapshots is a paid mutator transaction binding the contract method 0x421ae469.
+//
+// Solidity: function deleteSnapshots() returns()
+func (_Vm *VmTransactorSession) DeleteSnapshots() (*types.Transaction, error) {
+	return _Vm.Contract.DeleteSnapshots(&_Vm.TransactOpts)
+}
+
+// DeleteStateSnapshot is a paid mutator transaction binding the contract method 0x08d6b37a.
+//
+// Solidity: function deleteStateSnapshot(uint256 snapshotId) returns(bool success)
+func (_Vm *VmTransactor) DeleteStateSnapshot(opts *bind.TransactOpts, snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "deleteStateSnapshot", snapshotId)
+}
+
+// DeleteStateSnapshot is a paid mutator transaction binding the contract method 0x08d6b37a.
+//
+// Solidity: function deleteStateSnapshot(uint256 snapshotId) returns(bool success)
+func (_Vm *VmSession) DeleteStateSnapshot(snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.DeleteStateSnapshot(&_Vm.TransactOpts, snapshotId)
+}
+
+// DeleteStateSnapshot is a paid mutator transaction binding the contract method 0x08d6b37a.
+//
+// Solidity: function deleteStateSnapshot(uint256 snapshotId) returns(bool success)
+func (_Vm *VmTransactorSession) DeleteStateSnapshot(snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.DeleteStateSnapshot(&_Vm.TransactOpts, snapshotId)
+}
+
+// DeleteStateSnapshots is a paid mutator transaction binding the contract method 0xe0933c74.
+//
+// Solidity: function deleteStateSnapshots() returns()
+func (_Vm *VmTransactor) DeleteStateSnapshots(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "deleteStateSnapshots")
+}
+
+// DeleteStateSnapshots is a paid mutator transaction binding the contract method 0xe0933c74.
+//
+// Solidity: function deleteStateSnapshots() returns()
+func (_Vm *VmSession) DeleteStateSnapshots() (*types.Transaction, error) {
+	return _Vm.Contract.DeleteStateSnapshots(&_Vm.TransactOpts)
+}
+
+// DeleteStateSnapshots is a paid mutator transaction binding the contract method 0xe0933c74.
+//
+// Solidity: function deleteStateSnapshots() returns()
+func (_Vm *VmTransactorSession) DeleteStateSnapshots() (*types.Transaction, error) {
+	return _Vm.Contract.DeleteStateSnapshots(&_Vm.TransactOpts)
+}
+
+// DeployCode is a paid mutator transaction binding the contract method 0x29ce9dde.
+//
+// Solidity: function deployCode(string artifactPath, bytes constructorArgs) returns(address deployedAddress)
+func (_Vm *VmTransactor) DeployCode(opts *bind.TransactOpts, artifactPath string, constructorArgs []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "deployCode", artifactPath, constructorArgs)
+}
+
+// DeployCode is a paid mutator transaction binding the contract method 0x29ce9dde.
+//
+// Solidity: function deployCode(string artifactPath, bytes constructorArgs) returns(address deployedAddress)
+func (_Vm *VmSession) DeployCode(artifactPath string, constructorArgs []byte) (*types.Transaction, error) {
+	return _Vm.Contract.DeployCode(&_Vm.TransactOpts, artifactPath, constructorArgs)
+}
+
+// DeployCode is a paid mutator transaction binding the contract method 0x29ce9dde.
+//
+// Solidity: function deployCode(string artifactPath, bytes constructorArgs) returns(address deployedAddress)
+func (_Vm *VmTransactorSession) DeployCode(artifactPath string, constructorArgs []byte) (*types.Transaction, error) {
+	return _Vm.Contract.DeployCode(&_Vm.TransactOpts, artifactPath, constructorArgs)
+}
+
+// DeployCode0 is a paid mutator transaction binding the contract method 0x9a8325a0.
+//
+// Solidity: function deployCode(string artifactPath) returns(address deployedAddress)
+func (_Vm *VmTransactor) DeployCode0(opts *bind.TransactOpts, artifactPath string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "deployCode0", artifactPath)
+}
+
+// DeployCode0 is a paid mutator transaction binding the contract method 0x9a8325a0.
+//
+// Solidity: function deployCode(string artifactPath) returns(address deployedAddress)
+func (_Vm *VmSession) DeployCode0(artifactPath string) (*types.Transaction, error) {
+	return _Vm.Contract.DeployCode0(&_Vm.TransactOpts, artifactPath)
+}
+
+// DeployCode0 is a paid mutator transaction binding the contract method 0x9a8325a0.
+//
+// Solidity: function deployCode(string artifactPath) returns(address deployedAddress)
+func (_Vm *VmTransactorSession) DeployCode0(artifactPath string) (*types.Transaction, error) {
+	return _Vm.Contract.DeployCode0(&_Vm.TransactOpts, artifactPath)
+}
+
+// Difficulty is a paid mutator transaction binding the contract method 0x46cc92d9.
+//
+// Solidity: function difficulty(uint256 newDifficulty) returns()
+func (_Vm *VmTransactor) Difficulty(opts *bind.TransactOpts, newDifficulty *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "difficulty", newDifficulty)
+}
+
+// Difficulty is a paid mutator transaction binding the contract method 0x46cc92d9.
+//
+// Solidity: function difficulty(uint256 newDifficulty) returns()
+func (_Vm *VmSession) Difficulty(newDifficulty *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Difficulty(&_Vm.TransactOpts, newDifficulty)
+}
+
+// Difficulty is a paid mutator transaction binding the contract method 0x46cc92d9.
+//
+// Solidity: function difficulty(uint256 newDifficulty) returns()
+func (_Vm *VmTransactorSession) Difficulty(newDifficulty *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Difficulty(&_Vm.TransactOpts, newDifficulty)
+}
+
+// DumpState is a paid mutator transaction binding the contract method 0x709ecd3f.
+//
+// Solidity: function dumpState(string pathToStateJson) returns()
+func (_Vm *VmTransactor) DumpState(opts *bind.TransactOpts, pathToStateJson string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "dumpState", pathToStateJson)
+}
+
+// DumpState is a paid mutator transaction binding the contract method 0x709ecd3f.
+//
+// Solidity: function dumpState(string pathToStateJson) returns()
+func (_Vm *VmSession) DumpState(pathToStateJson string) (*types.Transaction, error) {
+	return _Vm.Contract.DumpState(&_Vm.TransactOpts, pathToStateJson)
+}
+
+// DumpState is a paid mutator transaction binding the contract method 0x709ecd3f.
+//
+// Solidity: function dumpState(string pathToStateJson) returns()
+func (_Vm *VmTransactorSession) DumpState(pathToStateJson string) (*types.Transaction, error) {
+	return _Vm.Contract.DumpState(&_Vm.TransactOpts, pathToStateJson)
+}
+
+// Etch is a paid mutator transaction binding the contract method 0xb4d6c782.
+//
+// Solidity: function etch(address target, bytes newRuntimeBytecode) returns()
+func (_Vm *VmTransactor) Etch(opts *bind.TransactOpts, target common.Address, newRuntimeBytecode []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "etch", target, newRuntimeBytecode)
+}
+
+// Etch is a paid mutator transaction binding the contract method 0xb4d6c782.
+//
+// Solidity: function etch(address target, bytes newRuntimeBytecode) returns()
+func (_Vm *VmSession) Etch(target common.Address, newRuntimeBytecode []byte) (*types.Transaction, error) {
+	return _Vm.Contract.Etch(&_Vm.TransactOpts, target, newRuntimeBytecode)
+}
+
+// Etch is a paid mutator transaction binding the contract method 0xb4d6c782.
+//
+// Solidity: function etch(address target, bytes newRuntimeBytecode) returns()
+func (_Vm *VmTransactorSession) Etch(target common.Address, newRuntimeBytecode []byte) (*types.Transaction, error) {
+	return _Vm.Contract.Etch(&_Vm.TransactOpts, target, newRuntimeBytecode)
+}
+
+// EthGetLogs is a paid mutator transaction binding the contract method 0x35e1349b.
+//
+// Solidity: function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] topics) returns((address,bytes32[],bytes,bytes32,uint64,bytes32,uint64,uint256,bool)[] logs)
+func (_Vm *VmTransactor) EthGetLogs(opts *bind.TransactOpts, fromBlock *big.Int, toBlock *big.Int, target common.Address, topics [][32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "eth_getLogs", fromBlock, toBlock, target, topics)
+}
+
+// EthGetLogs is a paid mutator transaction binding the contract method 0x35e1349b.
+//
+// Solidity: function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] topics) returns((address,bytes32[],bytes,bytes32,uint64,bytes32,uint64,uint256,bool)[] logs)
+func (_Vm *VmSession) EthGetLogs(fromBlock *big.Int, toBlock *big.Int, target common.Address, topics [][32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.EthGetLogs(&_Vm.TransactOpts, fromBlock, toBlock, target, topics)
+}
+
+// EthGetLogs is a paid mutator transaction binding the contract method 0x35e1349b.
+//
+// Solidity: function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] topics) returns((address,bytes32[],bytes,bytes32,uint64,bytes32,uint64,uint256,bool)[] logs)
+func (_Vm *VmTransactorSession) EthGetLogs(fromBlock *big.Int, toBlock *big.Int, target common.Address, topics [][32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.EthGetLogs(&_Vm.TransactOpts, fromBlock, toBlock, target, topics)
+}
+
+// ExpectCall is a paid mutator transaction binding the contract method 0x23361207.
+//
+// Solidity: function expectCall(address callee, uint256 msgValue, uint64 gas, bytes data) returns()
+func (_Vm *VmTransactor) ExpectCall(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, gas uint64, data []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectCall", callee, msgValue, gas, data)
+}
+
+// ExpectCall is a paid mutator transaction binding the contract method 0x23361207.
+//
+// Solidity: function expectCall(address callee, uint256 msgValue, uint64 gas, bytes data) returns()
+func (_Vm *VmSession) ExpectCall(callee common.Address, msgValue *big.Int, gas uint64, data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCall(&_Vm.TransactOpts, callee, msgValue, gas, data)
+}
+
+// ExpectCall is a paid mutator transaction binding the contract method 0x23361207.
+//
+// Solidity: function expectCall(address callee, uint256 msgValue, uint64 gas, bytes data) returns()
+func (_Vm *VmTransactorSession) ExpectCall(callee common.Address, msgValue *big.Int, gas uint64, data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCall(&_Vm.TransactOpts, callee, msgValue, gas, data)
+}
+
+// ExpectCall0 is a paid mutator transaction binding the contract method 0x65b7b7cc.
+//
+// Solidity: function expectCall(address callee, uint256 msgValue, uint64 gas, bytes data, uint64 count) returns()
+func (_Vm *VmTransactor) ExpectCall0(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, gas uint64, data []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectCall0", callee, msgValue, gas, data, count)
+}
+
+// ExpectCall0 is a paid mutator transaction binding the contract method 0x65b7b7cc.
+//
+// Solidity: function expectCall(address callee, uint256 msgValue, uint64 gas, bytes data, uint64 count) returns()
+func (_Vm *VmSession) ExpectCall0(callee common.Address, msgValue *big.Int, gas uint64, data []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCall0(&_Vm.TransactOpts, callee, msgValue, gas, data, count)
+}
+
+// ExpectCall0 is a paid mutator transaction binding the contract method 0x65b7b7cc.
+//
+// Solidity: function expectCall(address callee, uint256 msgValue, uint64 gas, bytes data, uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectCall0(callee common.Address, msgValue *big.Int, gas uint64, data []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCall0(&_Vm.TransactOpts, callee, msgValue, gas, data, count)
+}
+
+// ExpectCall1 is a paid mutator transaction binding the contract method 0xa2b1a1ae.
+//
+// Solidity: function expectCall(address callee, uint256 msgValue, bytes data, uint64 count) returns()
+func (_Vm *VmTransactor) ExpectCall1(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, data []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectCall1", callee, msgValue, data, count)
+}
+
+// ExpectCall1 is a paid mutator transaction binding the contract method 0xa2b1a1ae.
+//
+// Solidity: function expectCall(address callee, uint256 msgValue, bytes data, uint64 count) returns()
+func (_Vm *VmSession) ExpectCall1(callee common.Address, msgValue *big.Int, data []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCall1(&_Vm.TransactOpts, callee, msgValue, data, count)
+}
+
+// ExpectCall1 is a paid mutator transaction binding the contract method 0xa2b1a1ae.
+//
+// Solidity: function expectCall(address callee, uint256 msgValue, bytes data, uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectCall1(callee common.Address, msgValue *big.Int, data []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCall1(&_Vm.TransactOpts, callee, msgValue, data, count)
+}
+
+// ExpectCall2 is a paid mutator transaction binding the contract method 0xbd6af434.
+//
+// Solidity: function expectCall(address callee, bytes data) returns()
+func (_Vm *VmTransactor) ExpectCall2(opts *bind.TransactOpts, callee common.Address, data []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectCall2", callee, data)
+}
+
+// ExpectCall2 is a paid mutator transaction binding the contract method 0xbd6af434.
+//
+// Solidity: function expectCall(address callee, bytes data) returns()
+func (_Vm *VmSession) ExpectCall2(callee common.Address, data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCall2(&_Vm.TransactOpts, callee, data)
+}
+
+// ExpectCall2 is a paid mutator transaction binding the contract method 0xbd6af434.
+//
+// Solidity: function expectCall(address callee, bytes data) returns()
+func (_Vm *VmTransactorSession) ExpectCall2(callee common.Address, data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCall2(&_Vm.TransactOpts, callee, data)
+}
+
+// ExpectCall3 is a paid mutator transaction binding the contract method 0xc1adbbff.
+//
+// Solidity: function expectCall(address callee, bytes data, uint64 count) returns()
+func (_Vm *VmTransactor) ExpectCall3(opts *bind.TransactOpts, callee common.Address, data []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectCall3", callee, data, count)
+}
+
+// ExpectCall3 is a paid mutator transaction binding the contract method 0xc1adbbff.
+//
+// Solidity: function expectCall(address callee, bytes data, uint64 count) returns()
+func (_Vm *VmSession) ExpectCall3(callee common.Address, data []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCall3(&_Vm.TransactOpts, callee, data, count)
+}
+
+// ExpectCall3 is a paid mutator transaction binding the contract method 0xc1adbbff.
+//
+// Solidity: function expectCall(address callee, bytes data, uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectCall3(callee common.Address, data []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCall3(&_Vm.TransactOpts, callee, data, count)
+}
+
+// ExpectCall4 is a paid mutator transaction binding the contract method 0xf30c7ba3.
+//
+// Solidity: function expectCall(address callee, uint256 msgValue, bytes data) returns()
+func (_Vm *VmTransactor) ExpectCall4(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, data []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectCall4", callee, msgValue, data)
+}
+
+// ExpectCall4 is a paid mutator transaction binding the contract method 0xf30c7ba3.
+//
+// Solidity: function expectCall(address callee, uint256 msgValue, bytes data) returns()
+func (_Vm *VmSession) ExpectCall4(callee common.Address, msgValue *big.Int, data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCall4(&_Vm.TransactOpts, callee, msgValue, data)
+}
+
+// ExpectCall4 is a paid mutator transaction binding the contract method 0xf30c7ba3.
+//
+// Solidity: function expectCall(address callee, uint256 msgValue, bytes data) returns()
+func (_Vm *VmTransactorSession) ExpectCall4(callee common.Address, msgValue *big.Int, data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCall4(&_Vm.TransactOpts, callee, msgValue, data)
+}
+
+// ExpectCallMinGas is a paid mutator transaction binding the contract method 0x08e4e116.
+//
+// Solidity: function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes data) returns()
+func (_Vm *VmTransactor) ExpectCallMinGas(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, minGas uint64, data []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectCallMinGas", callee, msgValue, minGas, data)
+}
+
+// ExpectCallMinGas is a paid mutator transaction binding the contract method 0x08e4e116.
+//
+// Solidity: function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes data) returns()
+func (_Vm *VmSession) ExpectCallMinGas(callee common.Address, msgValue *big.Int, minGas uint64, data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCallMinGas(&_Vm.TransactOpts, callee, msgValue, minGas, data)
+}
+
+// ExpectCallMinGas is a paid mutator transaction binding the contract method 0x08e4e116.
+//
+// Solidity: function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes data) returns()
+func (_Vm *VmTransactorSession) ExpectCallMinGas(callee common.Address, msgValue *big.Int, minGas uint64, data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCallMinGas(&_Vm.TransactOpts, callee, msgValue, minGas, data)
+}
+
+// ExpectCallMinGas0 is a paid mutator transaction binding the contract method 0xe13a1834.
+//
+// Solidity: function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes data, uint64 count) returns()
+func (_Vm *VmTransactor) ExpectCallMinGas0(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, minGas uint64, data []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectCallMinGas0", callee, msgValue, minGas, data, count)
+}
+
+// ExpectCallMinGas0 is a paid mutator transaction binding the contract method 0xe13a1834.
+//
+// Solidity: function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes data, uint64 count) returns()
+func (_Vm *VmSession) ExpectCallMinGas0(callee common.Address, msgValue *big.Int, minGas uint64, data []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCallMinGas0(&_Vm.TransactOpts, callee, msgValue, minGas, data, count)
+}
+
+// ExpectCallMinGas0 is a paid mutator transaction binding the contract method 0xe13a1834.
+//
+// Solidity: function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes data, uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectCallMinGas0(callee common.Address, msgValue *big.Int, minGas uint64, data []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCallMinGas0(&_Vm.TransactOpts, callee, msgValue, minGas, data, count)
+}
+
+// ExpectCreate is a paid mutator transaction binding the contract method 0x73cdce36.
+//
+// Solidity: function expectCreate(bytes bytecode, address deployer) returns()
+func (_Vm *VmTransactor) ExpectCreate(opts *bind.TransactOpts, bytecode []byte, deployer common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectCreate", bytecode, deployer)
+}
+
+// ExpectCreate is a paid mutator transaction binding the contract method 0x73cdce36.
+//
+// Solidity: function expectCreate(bytes bytecode, address deployer) returns()
+func (_Vm *VmSession) ExpectCreate(bytecode []byte, deployer common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCreate(&_Vm.TransactOpts, bytecode, deployer)
+}
+
+// ExpectCreate is a paid mutator transaction binding the contract method 0x73cdce36.
+//
+// Solidity: function expectCreate(bytes bytecode, address deployer) returns()
+func (_Vm *VmTransactorSession) ExpectCreate(bytecode []byte, deployer common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCreate(&_Vm.TransactOpts, bytecode, deployer)
+}
+
+// ExpectCreate2 is a paid mutator transaction binding the contract method 0xea54a472.
+//
+// Solidity: function expectCreate2(bytes bytecode, address deployer) returns()
+func (_Vm *VmTransactor) ExpectCreate2(opts *bind.TransactOpts, bytecode []byte, deployer common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectCreate2", bytecode, deployer)
+}
+
+// ExpectCreate2 is a paid mutator transaction binding the contract method 0xea54a472.
+//
+// Solidity: function expectCreate2(bytes bytecode, address deployer) returns()
+func (_Vm *VmSession) ExpectCreate2(bytecode []byte, deployer common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCreate2(&_Vm.TransactOpts, bytecode, deployer)
+}
+
+// ExpectCreate2 is a paid mutator transaction binding the contract method 0xea54a472.
+//
+// Solidity: function expectCreate2(bytes bytecode, address deployer) returns()
+func (_Vm *VmTransactorSession) ExpectCreate2(bytecode []byte, deployer common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectCreate2(&_Vm.TransactOpts, bytecode, deployer)
+}
+
+// ExpectEmit is a paid mutator transaction binding the contract method 0x440ed10d.
+//
+// Solidity: function expectEmit() returns()
+func (_Vm *VmTransactor) ExpectEmit(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectEmit")
+}
+
+// ExpectEmit is a paid mutator transaction binding the contract method 0x440ed10d.
+//
+// Solidity: function expectEmit() returns()
+func (_Vm *VmSession) ExpectEmit() (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit(&_Vm.TransactOpts)
+}
+
+// ExpectEmit is a paid mutator transaction binding the contract method 0x440ed10d.
+//
+// Solidity: function expectEmit() returns()
+func (_Vm *VmTransactorSession) ExpectEmit() (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit(&_Vm.TransactOpts)
+}
+
+// ExpectEmit0 is a paid mutator transaction binding the contract method 0x491cc7c2.
+//
+// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) returns()
+func (_Vm *VmTransactor) ExpectEmit0(opts *bind.TransactOpts, checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectEmit0", checkTopic1, checkTopic2, checkTopic3, checkData)
+}
+
+// ExpectEmit0 is a paid mutator transaction binding the contract method 0x491cc7c2.
+//
+// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) returns()
+func (_Vm *VmSession) ExpectEmit0(checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit0(&_Vm.TransactOpts, checkTopic1, checkTopic2, checkTopic3, checkData)
+}
+
+// ExpectEmit0 is a paid mutator transaction binding the contract method 0x491cc7c2.
+//
+// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) returns()
+func (_Vm *VmTransactorSession) ExpectEmit0(checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit0(&_Vm.TransactOpts, checkTopic1, checkTopic2, checkTopic3, checkData)
+}
+
+// ExpectEmit1 is a paid mutator transaction binding the contract method 0x4c74a335.
+//
+// Solidity: function expectEmit(uint64 count) returns()
+func (_Vm *VmTransactor) ExpectEmit1(opts *bind.TransactOpts, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectEmit1", count)
+}
+
+// ExpectEmit1 is a paid mutator transaction binding the contract method 0x4c74a335.
+//
+// Solidity: function expectEmit(uint64 count) returns()
+func (_Vm *VmSession) ExpectEmit1(count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit1(&_Vm.TransactOpts, count)
+}
+
+// ExpectEmit1 is a paid mutator transaction binding the contract method 0x4c74a335.
+//
+// Solidity: function expectEmit(uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectEmit1(count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit1(&_Vm.TransactOpts, count)
+}
+
+// ExpectEmit2 is a paid mutator transaction binding the contract method 0x5e1d1c33.
+//
+// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) returns()
+func (_Vm *VmTransactor) ExpectEmit2(opts *bind.TransactOpts, checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectEmit2", checkTopic1, checkTopic2, checkTopic3, checkData, count)
+}
+
+// ExpectEmit2 is a paid mutator transaction binding the contract method 0x5e1d1c33.
+//
+// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) returns()
+func (_Vm *VmSession) ExpectEmit2(checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit2(&_Vm.TransactOpts, checkTopic1, checkTopic2, checkTopic3, checkData, count)
+}
+
+// ExpectEmit2 is a paid mutator transaction binding the contract method 0x5e1d1c33.
+//
+// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectEmit2(checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit2(&_Vm.TransactOpts, checkTopic1, checkTopic2, checkTopic3, checkData, count)
+}
+
+// ExpectEmit3 is a paid mutator transaction binding the contract method 0x81bad6f3.
+//
+// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter) returns()
+func (_Vm *VmTransactor) ExpectEmit3(opts *bind.TransactOpts, checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, emitter common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectEmit3", checkTopic1, checkTopic2, checkTopic3, checkData, emitter)
+}
+
+// ExpectEmit3 is a paid mutator transaction binding the contract method 0x81bad6f3.
+//
+// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter) returns()
+func (_Vm *VmSession) ExpectEmit3(checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, emitter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit3(&_Vm.TransactOpts, checkTopic1, checkTopic2, checkTopic3, checkData, emitter)
+}
+
+// ExpectEmit3 is a paid mutator transaction binding the contract method 0x81bad6f3.
+//
+// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter) returns()
+func (_Vm *VmTransactorSession) ExpectEmit3(checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, emitter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit3(&_Vm.TransactOpts, checkTopic1, checkTopic2, checkTopic3, checkData, emitter)
+}
+
+// ExpectEmit4 is a paid mutator transaction binding the contract method 0x86b9620d.
+//
+// Solidity: function expectEmit(address emitter) returns()
+func (_Vm *VmTransactor) ExpectEmit4(opts *bind.TransactOpts, emitter common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectEmit4", emitter)
+}
+
+// ExpectEmit4 is a paid mutator transaction binding the contract method 0x86b9620d.
+//
+// Solidity: function expectEmit(address emitter) returns()
+func (_Vm *VmSession) ExpectEmit4(emitter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit4(&_Vm.TransactOpts, emitter)
+}
+
+// ExpectEmit4 is a paid mutator transaction binding the contract method 0x86b9620d.
+//
+// Solidity: function expectEmit(address emitter) returns()
+func (_Vm *VmTransactorSession) ExpectEmit4(emitter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit4(&_Vm.TransactOpts, emitter)
+}
+
+// ExpectEmit5 is a paid mutator transaction binding the contract method 0xb43aece3.
+//
+// Solidity: function expectEmit(address emitter, uint64 count) returns()
+func (_Vm *VmTransactor) ExpectEmit5(opts *bind.TransactOpts, emitter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectEmit5", emitter, count)
+}
+
+// ExpectEmit5 is a paid mutator transaction binding the contract method 0xb43aece3.
+//
+// Solidity: function expectEmit(address emitter, uint64 count) returns()
+func (_Vm *VmSession) ExpectEmit5(emitter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit5(&_Vm.TransactOpts, emitter, count)
+}
+
+// ExpectEmit5 is a paid mutator transaction binding the contract method 0xb43aece3.
+//
+// Solidity: function expectEmit(address emitter, uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectEmit5(emitter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit5(&_Vm.TransactOpts, emitter, count)
+}
+
+// ExpectEmit6 is a paid mutator transaction binding the contract method 0xc339d02c.
+//
+// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter, uint64 count) returns()
+func (_Vm *VmTransactor) ExpectEmit6(opts *bind.TransactOpts, checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, emitter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectEmit6", checkTopic1, checkTopic2, checkTopic3, checkData, emitter, count)
+}
+
+// ExpectEmit6 is a paid mutator transaction binding the contract method 0xc339d02c.
+//
+// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter, uint64 count) returns()
+func (_Vm *VmSession) ExpectEmit6(checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, emitter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit6(&_Vm.TransactOpts, checkTopic1, checkTopic2, checkTopic3, checkData, emitter, count)
+}
+
+// ExpectEmit6 is a paid mutator transaction binding the contract method 0xc339d02c.
+//
+// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter, uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectEmit6(checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, emitter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmit6(&_Vm.TransactOpts, checkTopic1, checkTopic2, checkTopic3, checkData, emitter, count)
+}
+
+// ExpectEmitAnonymous is a paid mutator transaction binding the contract method 0x2e5f270c.
+//
+// Solidity: function expectEmitAnonymous() returns()
+func (_Vm *VmTransactor) ExpectEmitAnonymous(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectEmitAnonymous")
+}
+
+// ExpectEmitAnonymous is a paid mutator transaction binding the contract method 0x2e5f270c.
+//
+// Solidity: function expectEmitAnonymous() returns()
+func (_Vm *VmSession) ExpectEmitAnonymous() (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmitAnonymous(&_Vm.TransactOpts)
+}
+
+// ExpectEmitAnonymous is a paid mutator transaction binding the contract method 0x2e5f270c.
+//
+// Solidity: function expectEmitAnonymous() returns()
+func (_Vm *VmTransactorSession) ExpectEmitAnonymous() (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmitAnonymous(&_Vm.TransactOpts)
+}
+
+// ExpectEmitAnonymous0 is a paid mutator transaction binding the contract method 0x6fc68705.
+//
+// Solidity: function expectEmitAnonymous(address emitter) returns()
+func (_Vm *VmTransactor) ExpectEmitAnonymous0(opts *bind.TransactOpts, emitter common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectEmitAnonymous0", emitter)
+}
+
+// ExpectEmitAnonymous0 is a paid mutator transaction binding the contract method 0x6fc68705.
+//
+// Solidity: function expectEmitAnonymous(address emitter) returns()
+func (_Vm *VmSession) ExpectEmitAnonymous0(emitter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmitAnonymous0(&_Vm.TransactOpts, emitter)
+}
+
+// ExpectEmitAnonymous0 is a paid mutator transaction binding the contract method 0x6fc68705.
+//
+// Solidity: function expectEmitAnonymous(address emitter) returns()
+func (_Vm *VmTransactorSession) ExpectEmitAnonymous0(emitter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmitAnonymous0(&_Vm.TransactOpts, emitter)
+}
+
+// ExpectEmitAnonymous1 is a paid mutator transaction binding the contract method 0x71c95899.
+//
+// Solidity: function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter) returns()
+func (_Vm *VmTransactor) ExpectEmitAnonymous1(opts *bind.TransactOpts, checkTopic0 bool, checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, emitter common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectEmitAnonymous1", checkTopic0, checkTopic1, checkTopic2, checkTopic3, checkData, emitter)
+}
+
+// ExpectEmitAnonymous1 is a paid mutator transaction binding the contract method 0x71c95899.
+//
+// Solidity: function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter) returns()
+func (_Vm *VmSession) ExpectEmitAnonymous1(checkTopic0 bool, checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, emitter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmitAnonymous1(&_Vm.TransactOpts, checkTopic0, checkTopic1, checkTopic2, checkTopic3, checkData, emitter)
+}
+
+// ExpectEmitAnonymous1 is a paid mutator transaction binding the contract method 0x71c95899.
+//
+// Solidity: function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter) returns()
+func (_Vm *VmTransactorSession) ExpectEmitAnonymous1(checkTopic0 bool, checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, emitter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmitAnonymous1(&_Vm.TransactOpts, checkTopic0, checkTopic1, checkTopic2, checkTopic3, checkData, emitter)
+}
+
+// ExpectEmitAnonymous2 is a paid mutator transaction binding the contract method 0xc948db5e.
+//
+// Solidity: function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) returns()
+func (_Vm *VmTransactor) ExpectEmitAnonymous2(opts *bind.TransactOpts, checkTopic0 bool, checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectEmitAnonymous2", checkTopic0, checkTopic1, checkTopic2, checkTopic3, checkData)
+}
+
+// ExpectEmitAnonymous2 is a paid mutator transaction binding the contract method 0xc948db5e.
+//
+// Solidity: function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) returns()
+func (_Vm *VmSession) ExpectEmitAnonymous2(checkTopic0 bool, checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmitAnonymous2(&_Vm.TransactOpts, checkTopic0, checkTopic1, checkTopic2, checkTopic3, checkData)
+}
+
+// ExpectEmitAnonymous2 is a paid mutator transaction binding the contract method 0xc948db5e.
+//
+// Solidity: function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) returns()
+func (_Vm *VmTransactorSession) ExpectEmitAnonymous2(checkTopic0 bool, checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectEmitAnonymous2(&_Vm.TransactOpts, checkTopic0, checkTopic1, checkTopic2, checkTopic3, checkData)
+}
+
+// ExpectPartialRevert is a paid mutator transaction binding the contract method 0x11fb5b9c.
+//
+// Solidity: function expectPartialRevert(bytes4 revertData) returns()
+func (_Vm *VmTransactor) ExpectPartialRevert(opts *bind.TransactOpts, revertData [4]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectPartialRevert", revertData)
+}
+
+// ExpectPartialRevert is a paid mutator transaction binding the contract method 0x11fb5b9c.
+//
+// Solidity: function expectPartialRevert(bytes4 revertData) returns()
+func (_Vm *VmSession) ExpectPartialRevert(revertData [4]byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectPartialRevert(&_Vm.TransactOpts, revertData)
+}
+
+// ExpectPartialRevert is a paid mutator transaction binding the contract method 0x11fb5b9c.
+//
+// Solidity: function expectPartialRevert(bytes4 revertData) returns()
+func (_Vm *VmTransactorSession) ExpectPartialRevert(revertData [4]byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectPartialRevert(&_Vm.TransactOpts, revertData)
+}
+
+// ExpectPartialRevert0 is a paid mutator transaction binding the contract method 0x51aa008a.
+//
+// Solidity: function expectPartialRevert(bytes4 revertData, address reverter) returns()
+func (_Vm *VmTransactor) ExpectPartialRevert0(opts *bind.TransactOpts, revertData [4]byte, reverter common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectPartialRevert0", revertData, reverter)
+}
+
+// ExpectPartialRevert0 is a paid mutator transaction binding the contract method 0x51aa008a.
+//
+// Solidity: function expectPartialRevert(bytes4 revertData, address reverter) returns()
+func (_Vm *VmSession) ExpectPartialRevert0(revertData [4]byte, reverter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectPartialRevert0(&_Vm.TransactOpts, revertData, reverter)
+}
+
+// ExpectPartialRevert0 is a paid mutator transaction binding the contract method 0x51aa008a.
+//
+// Solidity: function expectPartialRevert(bytes4 revertData, address reverter) returns()
+func (_Vm *VmTransactorSession) ExpectPartialRevert0(revertData [4]byte, reverter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectPartialRevert0(&_Vm.TransactOpts, revertData, reverter)
+}
+
+// ExpectRevert is a paid mutator transaction binding the contract method 0x1ff5f952.
+//
+// Solidity: function expectRevert(address reverter, uint64 count) returns()
+func (_Vm *VmTransactor) ExpectRevert(opts *bind.TransactOpts, reverter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectRevert", reverter, count)
+}
+
+// ExpectRevert is a paid mutator transaction binding the contract method 0x1ff5f952.
+//
+// Solidity: function expectRevert(address reverter, uint64 count) returns()
+func (_Vm *VmSession) ExpectRevert(reverter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert(&_Vm.TransactOpts, reverter, count)
+}
+
+// ExpectRevert is a paid mutator transaction binding the contract method 0x1ff5f952.
+//
+// Solidity: function expectRevert(address reverter, uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectRevert(reverter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert(&_Vm.TransactOpts, reverter, count)
+}
+
+// ExpectRevert0 is a paid mutator transaction binding the contract method 0x260bc5de.
+//
+// Solidity: function expectRevert(bytes4 revertData, address reverter) returns()
+func (_Vm *VmTransactor) ExpectRevert0(opts *bind.TransactOpts, revertData [4]byte, reverter common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectRevert0", revertData, reverter)
+}
+
+// ExpectRevert0 is a paid mutator transaction binding the contract method 0x260bc5de.
+//
+// Solidity: function expectRevert(bytes4 revertData, address reverter) returns()
+func (_Vm *VmSession) ExpectRevert0(revertData [4]byte, reverter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert0(&_Vm.TransactOpts, revertData, reverter)
+}
+
+// ExpectRevert0 is a paid mutator transaction binding the contract method 0x260bc5de.
+//
+// Solidity: function expectRevert(bytes4 revertData, address reverter) returns()
+func (_Vm *VmTransactorSession) ExpectRevert0(revertData [4]byte, reverter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert0(&_Vm.TransactOpts, revertData, reverter)
+}
+
+// ExpectRevert1 is a paid mutator transaction binding the contract method 0x4994c273.
+//
+// Solidity: function expectRevert(bytes revertData, uint64 count) returns()
+func (_Vm *VmTransactor) ExpectRevert1(opts *bind.TransactOpts, revertData []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectRevert1", revertData, count)
+}
+
+// ExpectRevert1 is a paid mutator transaction binding the contract method 0x4994c273.
+//
+// Solidity: function expectRevert(bytes revertData, uint64 count) returns()
+func (_Vm *VmSession) ExpectRevert1(revertData []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert1(&_Vm.TransactOpts, revertData, count)
+}
+
+// ExpectRevert1 is a paid mutator transaction binding the contract method 0x4994c273.
+//
+// Solidity: function expectRevert(bytes revertData, uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectRevert1(revertData []byte, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert1(&_Vm.TransactOpts, revertData, count)
+}
+
+// ExpectRevert10 is a paid mutator transaction binding the contract method 0xf4844814.
+//
+// Solidity: function expectRevert() returns()
+func (_Vm *VmTransactor) ExpectRevert10(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectRevert10")
+}
+
+// ExpectRevert10 is a paid mutator transaction binding the contract method 0xf4844814.
+//
+// Solidity: function expectRevert() returns()
+func (_Vm *VmSession) ExpectRevert10() (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert10(&_Vm.TransactOpts)
+}
+
+// ExpectRevert10 is a paid mutator transaction binding the contract method 0xf4844814.
+//
+// Solidity: function expectRevert() returns()
+func (_Vm *VmTransactorSession) ExpectRevert10() (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert10(&_Vm.TransactOpts)
+}
+
+// ExpectRevert2 is a paid mutator transaction binding the contract method 0x4ee38244.
+//
+// Solidity: function expectRevert(uint64 count) returns()
+func (_Vm *VmTransactor) ExpectRevert2(opts *bind.TransactOpts, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectRevert2", count)
+}
+
+// ExpectRevert2 is a paid mutator transaction binding the contract method 0x4ee38244.
+//
+// Solidity: function expectRevert(uint64 count) returns()
+func (_Vm *VmSession) ExpectRevert2(count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert2(&_Vm.TransactOpts, count)
+}
+
+// ExpectRevert2 is a paid mutator transaction binding the contract method 0x4ee38244.
+//
+// Solidity: function expectRevert(uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectRevert2(count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert2(&_Vm.TransactOpts, count)
+}
+
+// ExpectRevert3 is a paid mutator transaction binding the contract method 0x61ebcf12.
+//
+// Solidity: function expectRevert(bytes revertData, address reverter) returns()
+func (_Vm *VmTransactor) ExpectRevert3(opts *bind.TransactOpts, revertData []byte, reverter common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectRevert3", revertData, reverter)
+}
+
+// ExpectRevert3 is a paid mutator transaction binding the contract method 0x61ebcf12.
+//
+// Solidity: function expectRevert(bytes revertData, address reverter) returns()
+func (_Vm *VmSession) ExpectRevert3(revertData []byte, reverter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert3(&_Vm.TransactOpts, revertData, reverter)
+}
+
+// ExpectRevert3 is a paid mutator transaction binding the contract method 0x61ebcf12.
+//
+// Solidity: function expectRevert(bytes revertData, address reverter) returns()
+func (_Vm *VmTransactorSession) ExpectRevert3(revertData []byte, reverter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert3(&_Vm.TransactOpts, revertData, reverter)
+}
+
+// ExpectRevert4 is a paid mutator transaction binding the contract method 0xb0762d73.
+//
+// Solidity: function expectRevert(bytes4 revertData, address reverter, uint64 count) returns()
+func (_Vm *VmTransactor) ExpectRevert4(opts *bind.TransactOpts, revertData [4]byte, reverter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectRevert4", revertData, reverter, count)
+}
+
+// ExpectRevert4 is a paid mutator transaction binding the contract method 0xb0762d73.
+//
+// Solidity: function expectRevert(bytes4 revertData, address reverter, uint64 count) returns()
+func (_Vm *VmSession) ExpectRevert4(revertData [4]byte, reverter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert4(&_Vm.TransactOpts, revertData, reverter, count)
+}
+
+// ExpectRevert4 is a paid mutator transaction binding the contract method 0xb0762d73.
+//
+// Solidity: function expectRevert(bytes4 revertData, address reverter, uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectRevert4(revertData [4]byte, reverter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert4(&_Vm.TransactOpts, revertData, reverter, count)
+}
+
+// ExpectRevert5 is a paid mutator transaction binding the contract method 0xc31eb0e0.
+//
+// Solidity: function expectRevert(bytes4 revertData) returns()
+func (_Vm *VmTransactor) ExpectRevert5(opts *bind.TransactOpts, revertData [4]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectRevert5", revertData)
+}
+
+// ExpectRevert5 is a paid mutator transaction binding the contract method 0xc31eb0e0.
+//
+// Solidity: function expectRevert(bytes4 revertData) returns()
+func (_Vm *VmSession) ExpectRevert5(revertData [4]byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert5(&_Vm.TransactOpts, revertData)
+}
+
+// ExpectRevert5 is a paid mutator transaction binding the contract method 0xc31eb0e0.
+//
+// Solidity: function expectRevert(bytes4 revertData) returns()
+func (_Vm *VmTransactorSession) ExpectRevert5(revertData [4]byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert5(&_Vm.TransactOpts, revertData)
+}
+
+// ExpectRevert6 is a paid mutator transaction binding the contract method 0xd345fb1f.
+//
+// Solidity: function expectRevert(bytes revertData, address reverter, uint64 count) returns()
+func (_Vm *VmTransactor) ExpectRevert6(opts *bind.TransactOpts, revertData []byte, reverter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectRevert6", revertData, reverter, count)
+}
+
+// ExpectRevert6 is a paid mutator transaction binding the contract method 0xd345fb1f.
+//
+// Solidity: function expectRevert(bytes revertData, address reverter, uint64 count) returns()
+func (_Vm *VmSession) ExpectRevert6(revertData []byte, reverter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert6(&_Vm.TransactOpts, revertData, reverter, count)
+}
+
+// ExpectRevert6 is a paid mutator transaction binding the contract method 0xd345fb1f.
+//
+// Solidity: function expectRevert(bytes revertData, address reverter, uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectRevert6(revertData []byte, reverter common.Address, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert6(&_Vm.TransactOpts, revertData, reverter, count)
+}
+
+// ExpectRevert7 is a paid mutator transaction binding the contract method 0xd814f38a.
+//
+// Solidity: function expectRevert(address reverter) returns()
+func (_Vm *VmTransactor) ExpectRevert7(opts *bind.TransactOpts, reverter common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectRevert7", reverter)
+}
+
+// ExpectRevert7 is a paid mutator transaction binding the contract method 0xd814f38a.
+//
+// Solidity: function expectRevert(address reverter) returns()
+func (_Vm *VmSession) ExpectRevert7(reverter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert7(&_Vm.TransactOpts, reverter)
+}
+
+// ExpectRevert7 is a paid mutator transaction binding the contract method 0xd814f38a.
+//
+// Solidity: function expectRevert(address reverter) returns()
+func (_Vm *VmTransactorSession) ExpectRevert7(reverter common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert7(&_Vm.TransactOpts, reverter)
+}
+
+// ExpectRevert8 is a paid mutator transaction binding the contract method 0xe45ca72d.
+//
+// Solidity: function expectRevert(bytes4 revertData, uint64 count) returns()
+func (_Vm *VmTransactor) ExpectRevert8(opts *bind.TransactOpts, revertData [4]byte, count uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectRevert8", revertData, count)
+}
+
+// ExpectRevert8 is a paid mutator transaction binding the contract method 0xe45ca72d.
+//
+// Solidity: function expectRevert(bytes4 revertData, uint64 count) returns()
+func (_Vm *VmSession) ExpectRevert8(revertData [4]byte, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert8(&_Vm.TransactOpts, revertData, count)
+}
+
+// ExpectRevert8 is a paid mutator transaction binding the contract method 0xe45ca72d.
+//
+// Solidity: function expectRevert(bytes4 revertData, uint64 count) returns()
+func (_Vm *VmTransactorSession) ExpectRevert8(revertData [4]byte, count uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert8(&_Vm.TransactOpts, revertData, count)
+}
+
+// ExpectRevert9 is a paid mutator transaction binding the contract method 0xf28dceb3.
+//
+// Solidity: function expectRevert(bytes revertData) returns()
+func (_Vm *VmTransactor) ExpectRevert9(opts *bind.TransactOpts, revertData []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectRevert9", revertData)
+}
+
+// ExpectRevert9 is a paid mutator transaction binding the contract method 0xf28dceb3.
+//
+// Solidity: function expectRevert(bytes revertData) returns()
+func (_Vm *VmSession) ExpectRevert9(revertData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert9(&_Vm.TransactOpts, revertData)
+}
+
+// ExpectRevert9 is a paid mutator transaction binding the contract method 0xf28dceb3.
+//
+// Solidity: function expectRevert(bytes revertData) returns()
+func (_Vm *VmTransactorSession) ExpectRevert9(revertData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectRevert9(&_Vm.TransactOpts, revertData)
+}
+
+// ExpectSafeMemory is a paid mutator transaction binding the contract method 0x6d016688.
+//
+// Solidity: function expectSafeMemory(uint64 min, uint64 max) returns()
+func (_Vm *VmTransactor) ExpectSafeMemory(opts *bind.TransactOpts, min uint64, max uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectSafeMemory", min, max)
+}
+
+// ExpectSafeMemory is a paid mutator transaction binding the contract method 0x6d016688.
+//
+// Solidity: function expectSafeMemory(uint64 min, uint64 max) returns()
+func (_Vm *VmSession) ExpectSafeMemory(min uint64, max uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectSafeMemory(&_Vm.TransactOpts, min, max)
+}
+
+// ExpectSafeMemory is a paid mutator transaction binding the contract method 0x6d016688.
+//
+// Solidity: function expectSafeMemory(uint64 min, uint64 max) returns()
+func (_Vm *VmTransactorSession) ExpectSafeMemory(min uint64, max uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectSafeMemory(&_Vm.TransactOpts, min, max)
+}
+
+// ExpectSafeMemoryCall is a paid mutator transaction binding the contract method 0x05838bf4.
+//
+// Solidity: function expectSafeMemoryCall(uint64 min, uint64 max) returns()
+func (_Vm *VmTransactor) ExpectSafeMemoryCall(opts *bind.TransactOpts, min uint64, max uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "expectSafeMemoryCall", min, max)
+}
+
+// ExpectSafeMemoryCall is a paid mutator transaction binding the contract method 0x05838bf4.
+//
+// Solidity: function expectSafeMemoryCall(uint64 min, uint64 max) returns()
+func (_Vm *VmSession) ExpectSafeMemoryCall(min uint64, max uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectSafeMemoryCall(&_Vm.TransactOpts, min, max)
+}
+
+// ExpectSafeMemoryCall is a paid mutator transaction binding the contract method 0x05838bf4.
+//
+// Solidity: function expectSafeMemoryCall(uint64 min, uint64 max) returns()
+func (_Vm *VmTransactorSession) ExpectSafeMemoryCall(min uint64, max uint64) (*types.Transaction, error) {
+	return _Vm.Contract.ExpectSafeMemoryCall(&_Vm.TransactOpts, min, max)
+}
+
+// Fee is a paid mutator transaction binding the contract method 0x39b37ab0.
+//
+// Solidity: function fee(uint256 newBasefee) returns()
+func (_Vm *VmTransactor) Fee(opts *bind.TransactOpts, newBasefee *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "fee", newBasefee)
+}
+
+// Fee is a paid mutator transaction binding the contract method 0x39b37ab0.
+//
+// Solidity: function fee(uint256 newBasefee) returns()
+func (_Vm *VmSession) Fee(newBasefee *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Fee(&_Vm.TransactOpts, newBasefee)
+}
+
+// Fee is a paid mutator transaction binding the contract method 0x39b37ab0.
+//
+// Solidity: function fee(uint256 newBasefee) returns()
+func (_Vm *VmTransactorSession) Fee(newBasefee *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Fee(&_Vm.TransactOpts, newBasefee)
+}
+
+// Ffi is a paid mutator transaction binding the contract method 0x89160467.
+//
+// Solidity: function ffi(string[] commandInput) returns(bytes result)
+func (_Vm *VmTransactor) Ffi(opts *bind.TransactOpts, commandInput []string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "ffi", commandInput)
+}
+
+// Ffi is a paid mutator transaction binding the contract method 0x89160467.
+//
+// Solidity: function ffi(string[] commandInput) returns(bytes result)
+func (_Vm *VmSession) Ffi(commandInput []string) (*types.Transaction, error) {
+	return _Vm.Contract.Ffi(&_Vm.TransactOpts, commandInput)
+}
+
+// Ffi is a paid mutator transaction binding the contract method 0x89160467.
+//
+// Solidity: function ffi(string[] commandInput) returns(bytes result)
+func (_Vm *VmTransactorSession) Ffi(commandInput []string) (*types.Transaction, error) {
+	return _Vm.Contract.Ffi(&_Vm.TransactOpts, commandInput)
+}
+
+// GetMappingKeyAndParentOf is a paid mutator transaction binding the contract method 0x876e24e6.
+//
+// Solidity: function getMappingKeyAndParentOf(address target, bytes32 elementSlot) returns(bool found, bytes32 key, bytes32 parent)
+func (_Vm *VmTransactor) GetMappingKeyAndParentOf(opts *bind.TransactOpts, target common.Address, elementSlot [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "getMappingKeyAndParentOf", target, elementSlot)
+}
+
+// GetMappingKeyAndParentOf is a paid mutator transaction binding the contract method 0x876e24e6.
+//
+// Solidity: function getMappingKeyAndParentOf(address target, bytes32 elementSlot) returns(bool found, bytes32 key, bytes32 parent)
+func (_Vm *VmSession) GetMappingKeyAndParentOf(target common.Address, elementSlot [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.GetMappingKeyAndParentOf(&_Vm.TransactOpts, target, elementSlot)
+}
+
+// GetMappingKeyAndParentOf is a paid mutator transaction binding the contract method 0x876e24e6.
+//
+// Solidity: function getMappingKeyAndParentOf(address target, bytes32 elementSlot) returns(bool found, bytes32 key, bytes32 parent)
+func (_Vm *VmTransactorSession) GetMappingKeyAndParentOf(target common.Address, elementSlot [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.GetMappingKeyAndParentOf(&_Vm.TransactOpts, target, elementSlot)
+}
+
+// GetMappingLength is a paid mutator transaction binding the contract method 0x2f2fd63f.
+//
+// Solidity: function getMappingLength(address target, bytes32 mappingSlot) returns(uint256 length)
+func (_Vm *VmTransactor) GetMappingLength(opts *bind.TransactOpts, target common.Address, mappingSlot [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "getMappingLength", target, mappingSlot)
+}
+
+// GetMappingLength is a paid mutator transaction binding the contract method 0x2f2fd63f.
+//
+// Solidity: function getMappingLength(address target, bytes32 mappingSlot) returns(uint256 length)
+func (_Vm *VmSession) GetMappingLength(target common.Address, mappingSlot [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.GetMappingLength(&_Vm.TransactOpts, target, mappingSlot)
+}
+
+// GetMappingLength is a paid mutator transaction binding the contract method 0x2f2fd63f.
+//
+// Solidity: function getMappingLength(address target, bytes32 mappingSlot) returns(uint256 length)
+func (_Vm *VmTransactorSession) GetMappingLength(target common.Address, mappingSlot [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.GetMappingLength(&_Vm.TransactOpts, target, mappingSlot)
+}
+
+// GetMappingSlotAt is a paid mutator transaction binding the contract method 0xebc73ab4.
+//
+// Solidity: function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) returns(bytes32 value)
+func (_Vm *VmTransactor) GetMappingSlotAt(opts *bind.TransactOpts, target common.Address, mappingSlot [32]byte, idx *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "getMappingSlotAt", target, mappingSlot, idx)
+}
+
+// GetMappingSlotAt is a paid mutator transaction binding the contract method 0xebc73ab4.
+//
+// Solidity: function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) returns(bytes32 value)
+func (_Vm *VmSession) GetMappingSlotAt(target common.Address, mappingSlot [32]byte, idx *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.GetMappingSlotAt(&_Vm.TransactOpts, target, mappingSlot, idx)
+}
+
+// GetMappingSlotAt is a paid mutator transaction binding the contract method 0xebc73ab4.
+//
+// Solidity: function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) returns(bytes32 value)
+func (_Vm *VmTransactorSession) GetMappingSlotAt(target common.Address, mappingSlot [32]byte, idx *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.GetMappingSlotAt(&_Vm.TransactOpts, target, mappingSlot, idx)
+}
+
+// GetNonce0 is a paid mutator transaction binding the contract method 0xa5748aad.
+//
+// Solidity: function getNonce((address,uint256,uint256,uint256) wallet) returns(uint64 nonce)
+func (_Vm *VmTransactor) GetNonce0(opts *bind.TransactOpts, wallet VmSafeWallet) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "getNonce0", wallet)
+}
+
+// GetNonce0 is a paid mutator transaction binding the contract method 0xa5748aad.
+//
+// Solidity: function getNonce((address,uint256,uint256,uint256) wallet) returns(uint64 nonce)
+func (_Vm *VmSession) GetNonce0(wallet VmSafeWallet) (*types.Transaction, error) {
+	return _Vm.Contract.GetNonce0(&_Vm.TransactOpts, wallet)
+}
+
+// GetNonce0 is a paid mutator transaction binding the contract method 0xa5748aad.
+//
+// Solidity: function getNonce((address,uint256,uint256,uint256) wallet) returns(uint64 nonce)
+func (_Vm *VmTransactorSession) GetNonce0(wallet VmSafeWallet) (*types.Transaction, error) {
+	return _Vm.Contract.GetNonce0(&_Vm.TransactOpts, wallet)
+}
+
+// GetRecordedLogs is a paid mutator transaction binding the contract method 0x191553a4.
+//
+// Solidity: function getRecordedLogs() returns((bytes32[],bytes,address)[] logs)
+func (_Vm *VmTransactor) GetRecordedLogs(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "getRecordedLogs")
+}
+
+// GetRecordedLogs is a paid mutator transaction binding the contract method 0x191553a4.
+//
+// Solidity: function getRecordedLogs() returns((bytes32[],bytes,address)[] logs)
+func (_Vm *VmSession) GetRecordedLogs() (*types.Transaction, error) {
+	return _Vm.Contract.GetRecordedLogs(&_Vm.TransactOpts)
+}
+
+// GetRecordedLogs is a paid mutator transaction binding the contract method 0x191553a4.
+//
+// Solidity: function getRecordedLogs() returns((bytes32[],bytes,address)[] logs)
+func (_Vm *VmTransactorSession) GetRecordedLogs() (*types.Transaction, error) {
+	return _Vm.Contract.GetRecordedLogs(&_Vm.TransactOpts)
+}
+
+// GetWallets is a paid mutator transaction binding the contract method 0xdb7a4605.
+//
+// Solidity: function getWallets() returns(address[] wallets)
+func (_Vm *VmTransactor) GetWallets(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "getWallets")
+}
+
+// GetWallets is a paid mutator transaction binding the contract method 0xdb7a4605.
+//
+// Solidity: function getWallets() returns(address[] wallets)
+func (_Vm *VmSession) GetWallets() (*types.Transaction, error) {
+	return _Vm.Contract.GetWallets(&_Vm.TransactOpts)
+}
+
+// GetWallets is a paid mutator transaction binding the contract method 0xdb7a4605.
+//
+// Solidity: function getWallets() returns(address[] wallets)
+func (_Vm *VmTransactorSession) GetWallets() (*types.Transaction, error) {
+	return _Vm.Contract.GetWallets(&_Vm.TransactOpts)
+}
+
+// Label is a paid mutator transaction binding the contract method 0xc657c718.
+//
+// Solidity: function label(address account, string newLabel) returns()
+func (_Vm *VmTransactor) Label(opts *bind.TransactOpts, account common.Address, newLabel string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "label", account, newLabel)
+}
+
+// Label is a paid mutator transaction binding the contract method 0xc657c718.
+//
+// Solidity: function label(address account, string newLabel) returns()
+func (_Vm *VmSession) Label(account common.Address, newLabel string) (*types.Transaction, error) {
+	return _Vm.Contract.Label(&_Vm.TransactOpts, account, newLabel)
+}
+
+// Label is a paid mutator transaction binding the contract method 0xc657c718.
+//
+// Solidity: function label(address account, string newLabel) returns()
+func (_Vm *VmTransactorSession) Label(account common.Address, newLabel string) (*types.Transaction, error) {
+	return _Vm.Contract.Label(&_Vm.TransactOpts, account, newLabel)
+}
+
+// LoadAllocs is a paid mutator transaction binding the contract method 0xb3a056d7.
+//
+// Solidity: function loadAllocs(string pathToAllocsJson) returns()
+func (_Vm *VmTransactor) LoadAllocs(opts *bind.TransactOpts, pathToAllocsJson string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "loadAllocs", pathToAllocsJson)
+}
+
+// LoadAllocs is a paid mutator transaction binding the contract method 0xb3a056d7.
+//
+// Solidity: function loadAllocs(string pathToAllocsJson) returns()
+func (_Vm *VmSession) LoadAllocs(pathToAllocsJson string) (*types.Transaction, error) {
+	return _Vm.Contract.LoadAllocs(&_Vm.TransactOpts, pathToAllocsJson)
+}
+
+// LoadAllocs is a paid mutator transaction binding the contract method 0xb3a056d7.
+//
+// Solidity: function loadAllocs(string pathToAllocsJson) returns()
+func (_Vm *VmTransactorSession) LoadAllocs(pathToAllocsJson string) (*types.Transaction, error) {
+	return _Vm.Contract.LoadAllocs(&_Vm.TransactOpts, pathToAllocsJson)
+}
+
+// MakePersistent is a paid mutator transaction binding the contract method 0x1d9e269e.
+//
+// Solidity: function makePersistent(address[] accounts) returns()
+func (_Vm *VmTransactor) MakePersistent(opts *bind.TransactOpts, accounts []common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "makePersistent", accounts)
+}
+
+// MakePersistent is a paid mutator transaction binding the contract method 0x1d9e269e.
+//
+// Solidity: function makePersistent(address[] accounts) returns()
+func (_Vm *VmSession) MakePersistent(accounts []common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.MakePersistent(&_Vm.TransactOpts, accounts)
+}
+
+// MakePersistent is a paid mutator transaction binding the contract method 0x1d9e269e.
+//
+// Solidity: function makePersistent(address[] accounts) returns()
+func (_Vm *VmTransactorSession) MakePersistent(accounts []common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.MakePersistent(&_Vm.TransactOpts, accounts)
+}
+
+// MakePersistent0 is a paid mutator transaction binding the contract method 0x4074e0a8.
+//
+// Solidity: function makePersistent(address account0, address account1) returns()
+func (_Vm *VmTransactor) MakePersistent0(opts *bind.TransactOpts, account0 common.Address, account1 common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "makePersistent0", account0, account1)
+}
+
+// MakePersistent0 is a paid mutator transaction binding the contract method 0x4074e0a8.
+//
+// Solidity: function makePersistent(address account0, address account1) returns()
+func (_Vm *VmSession) MakePersistent0(account0 common.Address, account1 common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.MakePersistent0(&_Vm.TransactOpts, account0, account1)
+}
+
+// MakePersistent0 is a paid mutator transaction binding the contract method 0x4074e0a8.
+//
+// Solidity: function makePersistent(address account0, address account1) returns()
+func (_Vm *VmTransactorSession) MakePersistent0(account0 common.Address, account1 common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.MakePersistent0(&_Vm.TransactOpts, account0, account1)
+}
+
+// MakePersistent1 is a paid mutator transaction binding the contract method 0x57e22dde.
+//
+// Solidity: function makePersistent(address account) returns()
+func (_Vm *VmTransactor) MakePersistent1(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "makePersistent1", account)
+}
+
+// MakePersistent1 is a paid mutator transaction binding the contract method 0x57e22dde.
+//
+// Solidity: function makePersistent(address account) returns()
+func (_Vm *VmSession) MakePersistent1(account common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.MakePersistent1(&_Vm.TransactOpts, account)
+}
+
+// MakePersistent1 is a paid mutator transaction binding the contract method 0x57e22dde.
+//
+// Solidity: function makePersistent(address account) returns()
+func (_Vm *VmTransactorSession) MakePersistent1(account common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.MakePersistent1(&_Vm.TransactOpts, account)
+}
+
+// MakePersistent2 is a paid mutator transaction binding the contract method 0xefb77a75.
+//
+// Solidity: function makePersistent(address account0, address account1, address account2) returns()
+func (_Vm *VmTransactor) MakePersistent2(opts *bind.TransactOpts, account0 common.Address, account1 common.Address, account2 common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "makePersistent2", account0, account1, account2)
+}
+
+// MakePersistent2 is a paid mutator transaction binding the contract method 0xefb77a75.
+//
+// Solidity: function makePersistent(address account0, address account1, address account2) returns()
+func (_Vm *VmSession) MakePersistent2(account0 common.Address, account1 common.Address, account2 common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.MakePersistent2(&_Vm.TransactOpts, account0, account1, account2)
+}
+
+// MakePersistent2 is a paid mutator transaction binding the contract method 0xefb77a75.
+//
+// Solidity: function makePersistent(address account0, address account1, address account2) returns()
+func (_Vm *VmTransactorSession) MakePersistent2(account0 common.Address, account1 common.Address, account2 common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.MakePersistent2(&_Vm.TransactOpts, account0, account1, account2)
+}
+
+// MockCall is a paid mutator transaction binding the contract method 0x08e0c537.
+//
+// Solidity: function mockCall(address callee, bytes4 data, bytes returnData) returns()
+func (_Vm *VmTransactor) MockCall(opts *bind.TransactOpts, callee common.Address, data [4]byte, returnData []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "mockCall", callee, data, returnData)
+}
+
+// MockCall is a paid mutator transaction binding the contract method 0x08e0c537.
+//
+// Solidity: function mockCall(address callee, bytes4 data, bytes returnData) returns()
+func (_Vm *VmSession) MockCall(callee common.Address, data [4]byte, returnData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCall(&_Vm.TransactOpts, callee, data, returnData)
+}
+
+// MockCall is a paid mutator transaction binding the contract method 0x08e0c537.
+//
+// Solidity: function mockCall(address callee, bytes4 data, bytes returnData) returns()
+func (_Vm *VmTransactorSession) MockCall(callee common.Address, data [4]byte, returnData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCall(&_Vm.TransactOpts, callee, data, returnData)
+}
+
+// MockCall0 is a paid mutator transaction binding the contract method 0x81409b91.
+//
+// Solidity: function mockCall(address callee, uint256 msgValue, bytes data, bytes returnData) returns()
+func (_Vm *VmTransactor) MockCall0(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, data []byte, returnData []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "mockCall0", callee, msgValue, data, returnData)
+}
+
+// MockCall0 is a paid mutator transaction binding the contract method 0x81409b91.
+//
+// Solidity: function mockCall(address callee, uint256 msgValue, bytes data, bytes returnData) returns()
+func (_Vm *VmSession) MockCall0(callee common.Address, msgValue *big.Int, data []byte, returnData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCall0(&_Vm.TransactOpts, callee, msgValue, data, returnData)
+}
+
+// MockCall0 is a paid mutator transaction binding the contract method 0x81409b91.
+//
+// Solidity: function mockCall(address callee, uint256 msgValue, bytes data, bytes returnData) returns()
+func (_Vm *VmTransactorSession) MockCall0(callee common.Address, msgValue *big.Int, data []byte, returnData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCall0(&_Vm.TransactOpts, callee, msgValue, data, returnData)
+}
+
+// MockCall1 is a paid mutator transaction binding the contract method 0xb96213e4.
+//
+// Solidity: function mockCall(address callee, bytes data, bytes returnData) returns()
+func (_Vm *VmTransactor) MockCall1(opts *bind.TransactOpts, callee common.Address, data []byte, returnData []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "mockCall1", callee, data, returnData)
+}
+
+// MockCall1 is a paid mutator transaction binding the contract method 0xb96213e4.
+//
+// Solidity: function mockCall(address callee, bytes data, bytes returnData) returns()
+func (_Vm *VmSession) MockCall1(callee common.Address, data []byte, returnData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCall1(&_Vm.TransactOpts, callee, data, returnData)
+}
+
+// MockCall1 is a paid mutator transaction binding the contract method 0xb96213e4.
+//
+// Solidity: function mockCall(address callee, bytes data, bytes returnData) returns()
+func (_Vm *VmTransactorSession) MockCall1(callee common.Address, data []byte, returnData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCall1(&_Vm.TransactOpts, callee, data, returnData)
+}
+
+// MockCall2 is a paid mutator transaction binding the contract method 0xe7b36a3d.
+//
+// Solidity: function mockCall(address callee, uint256 msgValue, bytes4 data, bytes returnData) returns()
+func (_Vm *VmTransactor) MockCall2(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, data [4]byte, returnData []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "mockCall2", callee, msgValue, data, returnData)
+}
+
+// MockCall2 is a paid mutator transaction binding the contract method 0xe7b36a3d.
+//
+// Solidity: function mockCall(address callee, uint256 msgValue, bytes4 data, bytes returnData) returns()
+func (_Vm *VmSession) MockCall2(callee common.Address, msgValue *big.Int, data [4]byte, returnData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCall2(&_Vm.TransactOpts, callee, msgValue, data, returnData)
+}
+
+// MockCall2 is a paid mutator transaction binding the contract method 0xe7b36a3d.
+//
+// Solidity: function mockCall(address callee, uint256 msgValue, bytes4 data, bytes returnData) returns()
+func (_Vm *VmTransactorSession) MockCall2(callee common.Address, msgValue *big.Int, data [4]byte, returnData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCall2(&_Vm.TransactOpts, callee, msgValue, data, returnData)
+}
+
+// MockCallRevert is a paid mutator transaction binding the contract method 0x2dfba5df.
+//
+// Solidity: function mockCallRevert(address callee, bytes4 data, bytes revertData) returns()
+func (_Vm *VmTransactor) MockCallRevert(opts *bind.TransactOpts, callee common.Address, data [4]byte, revertData []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "mockCallRevert", callee, data, revertData)
+}
+
+// MockCallRevert is a paid mutator transaction binding the contract method 0x2dfba5df.
+//
+// Solidity: function mockCallRevert(address callee, bytes4 data, bytes revertData) returns()
+func (_Vm *VmSession) MockCallRevert(callee common.Address, data [4]byte, revertData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCallRevert(&_Vm.TransactOpts, callee, data, revertData)
+}
+
+// MockCallRevert is a paid mutator transaction binding the contract method 0x2dfba5df.
+//
+// Solidity: function mockCallRevert(address callee, bytes4 data, bytes revertData) returns()
+func (_Vm *VmTransactorSession) MockCallRevert(callee common.Address, data [4]byte, revertData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCallRevert(&_Vm.TransactOpts, callee, data, revertData)
+}
+
+// MockCallRevert0 is a paid mutator transaction binding the contract method 0x596c8f04.
+//
+// Solidity: function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes revertData) returns()
+func (_Vm *VmTransactor) MockCallRevert0(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, data [4]byte, revertData []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "mockCallRevert0", callee, msgValue, data, revertData)
+}
+
+// MockCallRevert0 is a paid mutator transaction binding the contract method 0x596c8f04.
+//
+// Solidity: function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes revertData) returns()
+func (_Vm *VmSession) MockCallRevert0(callee common.Address, msgValue *big.Int, data [4]byte, revertData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCallRevert0(&_Vm.TransactOpts, callee, msgValue, data, revertData)
+}
+
+// MockCallRevert0 is a paid mutator transaction binding the contract method 0x596c8f04.
+//
+// Solidity: function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes revertData) returns()
+func (_Vm *VmTransactorSession) MockCallRevert0(callee common.Address, msgValue *big.Int, data [4]byte, revertData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCallRevert0(&_Vm.TransactOpts, callee, msgValue, data, revertData)
+}
+
+// MockCallRevert1 is a paid mutator transaction binding the contract method 0xd23cd037.
+//
+// Solidity: function mockCallRevert(address callee, uint256 msgValue, bytes data, bytes revertData) returns()
+func (_Vm *VmTransactor) MockCallRevert1(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, data []byte, revertData []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "mockCallRevert1", callee, msgValue, data, revertData)
+}
+
+// MockCallRevert1 is a paid mutator transaction binding the contract method 0xd23cd037.
+//
+// Solidity: function mockCallRevert(address callee, uint256 msgValue, bytes data, bytes revertData) returns()
+func (_Vm *VmSession) MockCallRevert1(callee common.Address, msgValue *big.Int, data []byte, revertData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCallRevert1(&_Vm.TransactOpts, callee, msgValue, data, revertData)
+}
+
+// MockCallRevert1 is a paid mutator transaction binding the contract method 0xd23cd037.
+//
+// Solidity: function mockCallRevert(address callee, uint256 msgValue, bytes data, bytes revertData) returns()
+func (_Vm *VmTransactorSession) MockCallRevert1(callee common.Address, msgValue *big.Int, data []byte, revertData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCallRevert1(&_Vm.TransactOpts, callee, msgValue, data, revertData)
+}
+
+// MockCallRevert2 is a paid mutator transaction binding the contract method 0xdbaad147.
+//
+// Solidity: function mockCallRevert(address callee, bytes data, bytes revertData) returns()
+func (_Vm *VmTransactor) MockCallRevert2(opts *bind.TransactOpts, callee common.Address, data []byte, revertData []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "mockCallRevert2", callee, data, revertData)
+}
+
+// MockCallRevert2 is a paid mutator transaction binding the contract method 0xdbaad147.
+//
+// Solidity: function mockCallRevert(address callee, bytes data, bytes revertData) returns()
+func (_Vm *VmSession) MockCallRevert2(callee common.Address, data []byte, revertData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCallRevert2(&_Vm.TransactOpts, callee, data, revertData)
+}
+
+// MockCallRevert2 is a paid mutator transaction binding the contract method 0xdbaad147.
+//
+// Solidity: function mockCallRevert(address callee, bytes data, bytes revertData) returns()
+func (_Vm *VmTransactorSession) MockCallRevert2(callee common.Address, data []byte, revertData []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCallRevert2(&_Vm.TransactOpts, callee, data, revertData)
+}
+
+// MockCalls is a paid mutator transaction binding the contract method 0x08bcbae1.
+//
+// Solidity: function mockCalls(address callee, uint256 msgValue, bytes data, bytes[] returnData) returns()
+func (_Vm *VmTransactor) MockCalls(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, data []byte, returnData [][]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "mockCalls", callee, msgValue, data, returnData)
+}
+
+// MockCalls is a paid mutator transaction binding the contract method 0x08bcbae1.
+//
+// Solidity: function mockCalls(address callee, uint256 msgValue, bytes data, bytes[] returnData) returns()
+func (_Vm *VmSession) MockCalls(callee common.Address, msgValue *big.Int, data []byte, returnData [][]byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCalls(&_Vm.TransactOpts, callee, msgValue, data, returnData)
+}
+
+// MockCalls is a paid mutator transaction binding the contract method 0x08bcbae1.
+//
+// Solidity: function mockCalls(address callee, uint256 msgValue, bytes data, bytes[] returnData) returns()
+func (_Vm *VmTransactorSession) MockCalls(callee common.Address, msgValue *big.Int, data []byte, returnData [][]byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCalls(&_Vm.TransactOpts, callee, msgValue, data, returnData)
+}
+
+// MockCalls0 is a paid mutator transaction binding the contract method 0x5c5c3de9.
+//
+// Solidity: function mockCalls(address callee, bytes data, bytes[] returnData) returns()
+func (_Vm *VmTransactor) MockCalls0(opts *bind.TransactOpts, callee common.Address, data []byte, returnData [][]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "mockCalls0", callee, data, returnData)
+}
+
+// MockCalls0 is a paid mutator transaction binding the contract method 0x5c5c3de9.
+//
+// Solidity: function mockCalls(address callee, bytes data, bytes[] returnData) returns()
+func (_Vm *VmSession) MockCalls0(callee common.Address, data []byte, returnData [][]byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCalls0(&_Vm.TransactOpts, callee, data, returnData)
+}
+
+// MockCalls0 is a paid mutator transaction binding the contract method 0x5c5c3de9.
+//
+// Solidity: function mockCalls(address callee, bytes data, bytes[] returnData) returns()
+func (_Vm *VmTransactorSession) MockCalls0(callee common.Address, data []byte, returnData [][]byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockCalls0(&_Vm.TransactOpts, callee, data, returnData)
+}
+
+// MockFunction is a paid mutator transaction binding the contract method 0xadf84d21.
+//
+// Solidity: function mockFunction(address callee, address target, bytes data) returns()
+func (_Vm *VmTransactor) MockFunction(opts *bind.TransactOpts, callee common.Address, target common.Address, data []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "mockFunction", callee, target, data)
+}
+
+// MockFunction is a paid mutator transaction binding the contract method 0xadf84d21.
+//
+// Solidity: function mockFunction(address callee, address target, bytes data) returns()
+func (_Vm *VmSession) MockFunction(callee common.Address, target common.Address, data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockFunction(&_Vm.TransactOpts, callee, target, data)
+}
+
+// MockFunction is a paid mutator transaction binding the contract method 0xadf84d21.
+//
+// Solidity: function mockFunction(address callee, address target, bytes data) returns()
+func (_Vm *VmTransactorSession) MockFunction(callee common.Address, target common.Address, data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.MockFunction(&_Vm.TransactOpts, callee, target, data)
+}
+
+// NoAccessList is a paid mutator transaction binding the contract method 0x238ad778.
+//
+// Solidity: function noAccessList() returns()
+func (_Vm *VmTransactor) NoAccessList(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "noAccessList")
+}
+
+// NoAccessList is a paid mutator transaction binding the contract method 0x238ad778.
+//
+// Solidity: function noAccessList() returns()
+func (_Vm *VmSession) NoAccessList() (*types.Transaction, error) {
+	return _Vm.Contract.NoAccessList(&_Vm.TransactOpts)
+}
+
+// NoAccessList is a paid mutator transaction binding the contract method 0x238ad778.
+//
+// Solidity: function noAccessList() returns()
+func (_Vm *VmTransactorSession) NoAccessList() (*types.Transaction, error) {
+	return _Vm.Contract.NoAccessList(&_Vm.TransactOpts)
+}
+
+// PauseGasMetering is a paid mutator transaction binding the contract method 0xd1a5b36f.
+//
+// Solidity: function pauseGasMetering() returns()
+func (_Vm *VmTransactor) PauseGasMetering(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "pauseGasMetering")
+}
+
+// PauseGasMetering is a paid mutator transaction binding the contract method 0xd1a5b36f.
+//
+// Solidity: function pauseGasMetering() returns()
+func (_Vm *VmSession) PauseGasMetering() (*types.Transaction, error) {
+	return _Vm.Contract.PauseGasMetering(&_Vm.TransactOpts)
+}
+
+// PauseGasMetering is a paid mutator transaction binding the contract method 0xd1a5b36f.
+//
+// Solidity: function pauseGasMetering() returns()
+func (_Vm *VmTransactorSession) PauseGasMetering() (*types.Transaction, error) {
+	return _Vm.Contract.PauseGasMetering(&_Vm.TransactOpts)
+}
+
+// Prank is a paid mutator transaction binding the contract method 0x47e50cce.
+//
+// Solidity: function prank(address msgSender, address txOrigin) returns()
+func (_Vm *VmTransactor) Prank(opts *bind.TransactOpts, msgSender common.Address, txOrigin common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "prank", msgSender, txOrigin)
+}
+
+// Prank is a paid mutator transaction binding the contract method 0x47e50cce.
+//
+// Solidity: function prank(address msgSender, address txOrigin) returns()
+func (_Vm *VmSession) Prank(msgSender common.Address, txOrigin common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.Prank(&_Vm.TransactOpts, msgSender, txOrigin)
+}
+
+// Prank is a paid mutator transaction binding the contract method 0x47e50cce.
+//
+// Solidity: function prank(address msgSender, address txOrigin) returns()
+func (_Vm *VmTransactorSession) Prank(msgSender common.Address, txOrigin common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.Prank(&_Vm.TransactOpts, msgSender, txOrigin)
+}
+
+// Prank0 is a paid mutator transaction binding the contract method 0x7d73d042.
+//
+// Solidity: function prank(address msgSender, address txOrigin, bool delegateCall) returns()
+func (_Vm *VmTransactor) Prank0(opts *bind.TransactOpts, msgSender common.Address, txOrigin common.Address, delegateCall bool) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "prank0", msgSender, txOrigin, delegateCall)
+}
+
+// Prank0 is a paid mutator transaction binding the contract method 0x7d73d042.
+//
+// Solidity: function prank(address msgSender, address txOrigin, bool delegateCall) returns()
+func (_Vm *VmSession) Prank0(msgSender common.Address, txOrigin common.Address, delegateCall bool) (*types.Transaction, error) {
+	return _Vm.Contract.Prank0(&_Vm.TransactOpts, msgSender, txOrigin, delegateCall)
+}
+
+// Prank0 is a paid mutator transaction binding the contract method 0x7d73d042.
+//
+// Solidity: function prank(address msgSender, address txOrigin, bool delegateCall) returns()
+func (_Vm *VmTransactorSession) Prank0(msgSender common.Address, txOrigin common.Address, delegateCall bool) (*types.Transaction, error) {
+	return _Vm.Contract.Prank0(&_Vm.TransactOpts, msgSender, txOrigin, delegateCall)
+}
+
+// Prank1 is a paid mutator transaction binding the contract method 0xa7f8bf5c.
+//
+// Solidity: function prank(address msgSender, bool delegateCall) returns()
+func (_Vm *VmTransactor) Prank1(opts *bind.TransactOpts, msgSender common.Address, delegateCall bool) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "prank1", msgSender, delegateCall)
+}
+
+// Prank1 is a paid mutator transaction binding the contract method 0xa7f8bf5c.
+//
+// Solidity: function prank(address msgSender, bool delegateCall) returns()
+func (_Vm *VmSession) Prank1(msgSender common.Address, delegateCall bool) (*types.Transaction, error) {
+	return _Vm.Contract.Prank1(&_Vm.TransactOpts, msgSender, delegateCall)
+}
+
+// Prank1 is a paid mutator transaction binding the contract method 0xa7f8bf5c.
+//
+// Solidity: function prank(address msgSender, bool delegateCall) returns()
+func (_Vm *VmTransactorSession) Prank1(msgSender common.Address, delegateCall bool) (*types.Transaction, error) {
+	return _Vm.Contract.Prank1(&_Vm.TransactOpts, msgSender, delegateCall)
+}
+
+// Prank2 is a paid mutator transaction binding the contract method 0xca669fa7.
+//
+// Solidity: function prank(address msgSender) returns()
+func (_Vm *VmTransactor) Prank2(opts *bind.TransactOpts, msgSender common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "prank2", msgSender)
+}
+
+// Prank2 is a paid mutator transaction binding the contract method 0xca669fa7.
+//
+// Solidity: function prank(address msgSender) returns()
+func (_Vm *VmSession) Prank2(msgSender common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.Prank2(&_Vm.TransactOpts, msgSender)
+}
+
+// Prank2 is a paid mutator transaction binding the contract method 0xca669fa7.
+//
+// Solidity: function prank(address msgSender) returns()
+func (_Vm *VmTransactorSession) Prank2(msgSender common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.Prank2(&_Vm.TransactOpts, msgSender)
+}
+
+// Prevrandao is a paid mutator transaction binding the contract method 0x3b925549.
+//
+// Solidity: function prevrandao(bytes32 newPrevrandao) returns()
+func (_Vm *VmTransactor) Prevrandao(opts *bind.TransactOpts, newPrevrandao [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "prevrandao", newPrevrandao)
+}
+
+// Prevrandao is a paid mutator transaction binding the contract method 0x3b925549.
+//
+// Solidity: function prevrandao(bytes32 newPrevrandao) returns()
+func (_Vm *VmSession) Prevrandao(newPrevrandao [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.Prevrandao(&_Vm.TransactOpts, newPrevrandao)
+}
+
+// Prevrandao is a paid mutator transaction binding the contract method 0x3b925549.
+//
+// Solidity: function prevrandao(bytes32 newPrevrandao) returns()
+func (_Vm *VmTransactorSession) Prevrandao(newPrevrandao [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.Prevrandao(&_Vm.TransactOpts, newPrevrandao)
+}
+
+// Prevrandao0 is a paid mutator transaction binding the contract method 0x9cb1c0d4.
+//
+// Solidity: function prevrandao(uint256 newPrevrandao) returns()
+func (_Vm *VmTransactor) Prevrandao0(opts *bind.TransactOpts, newPrevrandao *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "prevrandao0", newPrevrandao)
+}
+
+// Prevrandao0 is a paid mutator transaction binding the contract method 0x9cb1c0d4.
+//
+// Solidity: function prevrandao(uint256 newPrevrandao) returns()
+func (_Vm *VmSession) Prevrandao0(newPrevrandao *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Prevrandao0(&_Vm.TransactOpts, newPrevrandao)
+}
+
+// Prevrandao0 is a paid mutator transaction binding the contract method 0x9cb1c0d4.
+//
+// Solidity: function prevrandao(uint256 newPrevrandao) returns()
+func (_Vm *VmTransactorSession) Prevrandao0(newPrevrandao *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Prevrandao0(&_Vm.TransactOpts, newPrevrandao)
+}
+
+// Prompt is a paid mutator transaction binding the contract method 0x47eaf474.
+//
+// Solidity: function prompt(string promptText) returns(string input)
+func (_Vm *VmTransactor) Prompt(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "prompt", promptText)
+}
+
+// Prompt is a paid mutator transaction binding the contract method 0x47eaf474.
+//
+// Solidity: function prompt(string promptText) returns(string input)
+func (_Vm *VmSession) Prompt(promptText string) (*types.Transaction, error) {
+	return _Vm.Contract.Prompt(&_Vm.TransactOpts, promptText)
+}
+
+// Prompt is a paid mutator transaction binding the contract method 0x47eaf474.
+//
+// Solidity: function prompt(string promptText) returns(string input)
+func (_Vm *VmTransactorSession) Prompt(promptText string) (*types.Transaction, error) {
+	return _Vm.Contract.Prompt(&_Vm.TransactOpts, promptText)
+}
+
+// PromptAddress is a paid mutator transaction binding the contract method 0x62ee05f4.
+//
+// Solidity: function promptAddress(string promptText) returns(address)
+func (_Vm *VmTransactor) PromptAddress(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "promptAddress", promptText)
+}
+
+// PromptAddress is a paid mutator transaction binding the contract method 0x62ee05f4.
+//
+// Solidity: function promptAddress(string promptText) returns(address)
+func (_Vm *VmSession) PromptAddress(promptText string) (*types.Transaction, error) {
+	return _Vm.Contract.PromptAddress(&_Vm.TransactOpts, promptText)
+}
+
+// PromptAddress is a paid mutator transaction binding the contract method 0x62ee05f4.
+//
+// Solidity: function promptAddress(string promptText) returns(address)
+func (_Vm *VmTransactorSession) PromptAddress(promptText string) (*types.Transaction, error) {
+	return _Vm.Contract.PromptAddress(&_Vm.TransactOpts, promptText)
+}
+
+// PromptSecret is a paid mutator transaction binding the contract method 0x1e279d41.
+//
+// Solidity: function promptSecret(string promptText) returns(string input)
+func (_Vm *VmTransactor) PromptSecret(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "promptSecret", promptText)
+}
+
+// PromptSecret is a paid mutator transaction binding the contract method 0x1e279d41.
+//
+// Solidity: function promptSecret(string promptText) returns(string input)
+func (_Vm *VmSession) PromptSecret(promptText string) (*types.Transaction, error) {
+	return _Vm.Contract.PromptSecret(&_Vm.TransactOpts, promptText)
+}
+
+// PromptSecret is a paid mutator transaction binding the contract method 0x1e279d41.
+//
+// Solidity: function promptSecret(string promptText) returns(string input)
+func (_Vm *VmTransactorSession) PromptSecret(promptText string) (*types.Transaction, error) {
+	return _Vm.Contract.PromptSecret(&_Vm.TransactOpts, promptText)
+}
+
+// PromptSecretUint is a paid mutator transaction binding the contract method 0x69ca02b7.
+//
+// Solidity: function promptSecretUint(string promptText) returns(uint256)
+func (_Vm *VmTransactor) PromptSecretUint(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "promptSecretUint", promptText)
+}
+
+// PromptSecretUint is a paid mutator transaction binding the contract method 0x69ca02b7.
+//
+// Solidity: function promptSecretUint(string promptText) returns(uint256)
+func (_Vm *VmSession) PromptSecretUint(promptText string) (*types.Transaction, error) {
+	return _Vm.Contract.PromptSecretUint(&_Vm.TransactOpts, promptText)
+}
+
+// PromptSecretUint is a paid mutator transaction binding the contract method 0x69ca02b7.
+//
+// Solidity: function promptSecretUint(string promptText) returns(uint256)
+func (_Vm *VmTransactorSession) PromptSecretUint(promptText string) (*types.Transaction, error) {
+	return _Vm.Contract.PromptSecretUint(&_Vm.TransactOpts, promptText)
+}
+
+// PromptUint is a paid mutator transaction binding the contract method 0x652fd489.
+//
+// Solidity: function promptUint(string promptText) returns(uint256)
+func (_Vm *VmTransactor) PromptUint(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "promptUint", promptText)
+}
+
+// PromptUint is a paid mutator transaction binding the contract method 0x652fd489.
+//
+// Solidity: function promptUint(string promptText) returns(uint256)
+func (_Vm *VmSession) PromptUint(promptText string) (*types.Transaction, error) {
+	return _Vm.Contract.PromptUint(&_Vm.TransactOpts, promptText)
+}
+
+// PromptUint is a paid mutator transaction binding the contract method 0x652fd489.
+//
+// Solidity: function promptUint(string promptText) returns(uint256)
+func (_Vm *VmTransactorSession) PromptUint(promptText string) (*types.Transaction, error) {
+	return _Vm.Contract.PromptUint(&_Vm.TransactOpts, promptText)
+}
+
+// RandomAddress is a paid mutator transaction binding the contract method 0xd5bee9f5.
+//
+// Solidity: function randomAddress() returns(address)
+func (_Vm *VmTransactor) RandomAddress(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "randomAddress")
+}
+
+// RandomAddress is a paid mutator transaction binding the contract method 0xd5bee9f5.
+//
+// Solidity: function randomAddress() returns(address)
+func (_Vm *VmSession) RandomAddress() (*types.Transaction, error) {
+	return _Vm.Contract.RandomAddress(&_Vm.TransactOpts)
+}
+
+// RandomAddress is a paid mutator transaction binding the contract method 0xd5bee9f5.
+//
+// Solidity: function randomAddress() returns(address)
+func (_Vm *VmTransactorSession) RandomAddress() (*types.Transaction, error) {
+	return _Vm.Contract.RandomAddress(&_Vm.TransactOpts)
+}
+
+// RandomUint is a paid mutator transaction binding the contract method 0x25124730.
+//
+// Solidity: function randomUint() returns(uint256)
+func (_Vm *VmTransactor) RandomUint(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "randomUint")
+}
+
+// RandomUint is a paid mutator transaction binding the contract method 0x25124730.
+//
+// Solidity: function randomUint() returns(uint256)
+func (_Vm *VmSession) RandomUint() (*types.Transaction, error) {
+	return _Vm.Contract.RandomUint(&_Vm.TransactOpts)
+}
+
+// RandomUint is a paid mutator transaction binding the contract method 0x25124730.
+//
+// Solidity: function randomUint() returns(uint256)
+func (_Vm *VmTransactorSession) RandomUint() (*types.Transaction, error) {
+	return _Vm.Contract.RandomUint(&_Vm.TransactOpts)
+}
+
+// RandomUint1 is a paid mutator transaction binding the contract method 0xd61b051b.
+//
+// Solidity: function randomUint(uint256 min, uint256 max) returns(uint256)
+func (_Vm *VmTransactor) RandomUint1(opts *bind.TransactOpts, min *big.Int, max *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "randomUint1", min, max)
+}
+
+// RandomUint1 is a paid mutator transaction binding the contract method 0xd61b051b.
+//
+// Solidity: function randomUint(uint256 min, uint256 max) returns(uint256)
+func (_Vm *VmSession) RandomUint1(min *big.Int, max *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RandomUint1(&_Vm.TransactOpts, min, max)
+}
+
+// RandomUint1 is a paid mutator transaction binding the contract method 0xd61b051b.
+//
+// Solidity: function randomUint(uint256 min, uint256 max) returns(uint256)
+func (_Vm *VmTransactorSession) RandomUint1(min *big.Int, max *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RandomUint1(&_Vm.TransactOpts, min, max)
+}
+
+// ReadCallers is a paid mutator transaction binding the contract method 0x4ad0bac9.
+//
+// Solidity: function readCallers() returns(uint8 callerMode, address msgSender, address txOrigin)
+func (_Vm *VmTransactor) ReadCallers(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "readCallers")
+}
+
+// ReadCallers is a paid mutator transaction binding the contract method 0x4ad0bac9.
+//
+// Solidity: function readCallers() returns(uint8 callerMode, address msgSender, address txOrigin)
+func (_Vm *VmSession) ReadCallers() (*types.Transaction, error) {
+	return _Vm.Contract.ReadCallers(&_Vm.TransactOpts)
+}
+
+// ReadCallers is a paid mutator transaction binding the contract method 0x4ad0bac9.
+//
+// Solidity: function readCallers() returns(uint8 callerMode, address msgSender, address txOrigin)
+func (_Vm *VmTransactorSession) ReadCallers() (*types.Transaction, error) {
+	return _Vm.Contract.ReadCallers(&_Vm.TransactOpts)
+}
+
+// Record is a paid mutator transaction binding the contract method 0x266cf109.
+//
+// Solidity: function record() returns()
+func (_Vm *VmTransactor) Record(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "record")
+}
+
+// Record is a paid mutator transaction binding the contract method 0x266cf109.
+//
+// Solidity: function record() returns()
+func (_Vm *VmSession) Record() (*types.Transaction, error) {
+	return _Vm.Contract.Record(&_Vm.TransactOpts)
+}
+
+// Record is a paid mutator transaction binding the contract method 0x266cf109.
+//
+// Solidity: function record() returns()
+func (_Vm *VmTransactorSession) Record() (*types.Transaction, error) {
+	return _Vm.Contract.Record(&_Vm.TransactOpts)
+}
+
+// RecordLogs is a paid mutator transaction binding the contract method 0x41af2f52.
+//
+// Solidity: function recordLogs() returns()
+func (_Vm *VmTransactor) RecordLogs(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "recordLogs")
+}
+
+// RecordLogs is a paid mutator transaction binding the contract method 0x41af2f52.
+//
+// Solidity: function recordLogs() returns()
+func (_Vm *VmSession) RecordLogs() (*types.Transaction, error) {
+	return _Vm.Contract.RecordLogs(&_Vm.TransactOpts)
+}
+
+// RecordLogs is a paid mutator transaction binding the contract method 0x41af2f52.
+//
+// Solidity: function recordLogs() returns()
+func (_Vm *VmTransactorSession) RecordLogs() (*types.Transaction, error) {
+	return _Vm.Contract.RecordLogs(&_Vm.TransactOpts)
+}
+
+// RememberKey is a paid mutator transaction binding the contract method 0x22100064.
+//
+// Solidity: function rememberKey(uint256 privateKey) returns(address keyAddr)
+func (_Vm *VmTransactor) RememberKey(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "rememberKey", privateKey)
+}
+
+// RememberKey is a paid mutator transaction binding the contract method 0x22100064.
+//
+// Solidity: function rememberKey(uint256 privateKey) returns(address keyAddr)
+func (_Vm *VmSession) RememberKey(privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RememberKey(&_Vm.TransactOpts, privateKey)
+}
+
+// RememberKey is a paid mutator transaction binding the contract method 0x22100064.
+//
+// Solidity: function rememberKey(uint256 privateKey) returns(address keyAddr)
+func (_Vm *VmTransactorSession) RememberKey(privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RememberKey(&_Vm.TransactOpts, privateKey)
+}
+
+// RememberKeys is a paid mutator transaction binding the contract method 0x97cb9189.
+//
+// Solidity: function rememberKeys(string mnemonic, string derivationPath, uint32 count) returns(address[] keyAddrs)
+func (_Vm *VmTransactor) RememberKeys(opts *bind.TransactOpts, mnemonic string, derivationPath string, count uint32) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "rememberKeys", mnemonic, derivationPath, count)
+}
+
+// RememberKeys is a paid mutator transaction binding the contract method 0x97cb9189.
+//
+// Solidity: function rememberKeys(string mnemonic, string derivationPath, uint32 count) returns(address[] keyAddrs)
+func (_Vm *VmSession) RememberKeys(mnemonic string, derivationPath string, count uint32) (*types.Transaction, error) {
+	return _Vm.Contract.RememberKeys(&_Vm.TransactOpts, mnemonic, derivationPath, count)
+}
+
+// RememberKeys is a paid mutator transaction binding the contract method 0x97cb9189.
+//
+// Solidity: function rememberKeys(string mnemonic, string derivationPath, uint32 count) returns(address[] keyAddrs)
+func (_Vm *VmTransactorSession) RememberKeys(mnemonic string, derivationPath string, count uint32) (*types.Transaction, error) {
+	return _Vm.Contract.RememberKeys(&_Vm.TransactOpts, mnemonic, derivationPath, count)
+}
+
+// RememberKeys0 is a paid mutator transaction binding the contract method 0xf8d58eaf.
+//
+// Solidity: function rememberKeys(string mnemonic, string derivationPath, string language, uint32 count) returns(address[] keyAddrs)
+func (_Vm *VmTransactor) RememberKeys0(opts *bind.TransactOpts, mnemonic string, derivationPath string, language string, count uint32) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "rememberKeys0", mnemonic, derivationPath, language, count)
+}
+
+// RememberKeys0 is a paid mutator transaction binding the contract method 0xf8d58eaf.
+//
+// Solidity: function rememberKeys(string mnemonic, string derivationPath, string language, uint32 count) returns(address[] keyAddrs)
+func (_Vm *VmSession) RememberKeys0(mnemonic string, derivationPath string, language string, count uint32) (*types.Transaction, error) {
+	return _Vm.Contract.RememberKeys0(&_Vm.TransactOpts, mnemonic, derivationPath, language, count)
+}
+
+// RememberKeys0 is a paid mutator transaction binding the contract method 0xf8d58eaf.
+//
+// Solidity: function rememberKeys(string mnemonic, string derivationPath, string language, uint32 count) returns(address[] keyAddrs)
+func (_Vm *VmTransactorSession) RememberKeys0(mnemonic string, derivationPath string, language string, count uint32) (*types.Transaction, error) {
+	return _Vm.Contract.RememberKeys0(&_Vm.TransactOpts, mnemonic, derivationPath, language, count)
+}
+
+// RemoveDir is a paid mutator transaction binding the contract method 0x45c62011.
+//
+// Solidity: function removeDir(string path, bool recursive) returns()
+func (_Vm *VmTransactor) RemoveDir(opts *bind.TransactOpts, path string, recursive bool) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "removeDir", path, recursive)
+}
+
+// RemoveDir is a paid mutator transaction binding the contract method 0x45c62011.
+//
+// Solidity: function removeDir(string path, bool recursive) returns()
+func (_Vm *VmSession) RemoveDir(path string, recursive bool) (*types.Transaction, error) {
+	return _Vm.Contract.RemoveDir(&_Vm.TransactOpts, path, recursive)
+}
+
+// RemoveDir is a paid mutator transaction binding the contract method 0x45c62011.
+//
+// Solidity: function removeDir(string path, bool recursive) returns()
+func (_Vm *VmTransactorSession) RemoveDir(path string, recursive bool) (*types.Transaction, error) {
+	return _Vm.Contract.RemoveDir(&_Vm.TransactOpts, path, recursive)
+}
+
+// RemoveFile is a paid mutator transaction binding the contract method 0xf1afe04d.
+//
+// Solidity: function removeFile(string path) returns()
+func (_Vm *VmTransactor) RemoveFile(opts *bind.TransactOpts, path string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "removeFile", path)
+}
+
+// RemoveFile is a paid mutator transaction binding the contract method 0xf1afe04d.
+//
+// Solidity: function removeFile(string path) returns()
+func (_Vm *VmSession) RemoveFile(path string) (*types.Transaction, error) {
+	return _Vm.Contract.RemoveFile(&_Vm.TransactOpts, path)
+}
+
+// RemoveFile is a paid mutator transaction binding the contract method 0xf1afe04d.
+//
+// Solidity: function removeFile(string path) returns()
+func (_Vm *VmTransactorSession) RemoveFile(path string) (*types.Transaction, error) {
+	return _Vm.Contract.RemoveFile(&_Vm.TransactOpts, path)
+}
+
+// ResetGasMetering is a paid mutator transaction binding the contract method 0xbe367dd3.
+//
+// Solidity: function resetGasMetering() returns()
+func (_Vm *VmTransactor) ResetGasMetering(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "resetGasMetering")
+}
+
+// ResetGasMetering is a paid mutator transaction binding the contract method 0xbe367dd3.
+//
+// Solidity: function resetGasMetering() returns()
+func (_Vm *VmSession) ResetGasMetering() (*types.Transaction, error) {
+	return _Vm.Contract.ResetGasMetering(&_Vm.TransactOpts)
+}
+
+// ResetGasMetering is a paid mutator transaction binding the contract method 0xbe367dd3.
+//
+// Solidity: function resetGasMetering() returns()
+func (_Vm *VmTransactorSession) ResetGasMetering() (*types.Transaction, error) {
+	return _Vm.Contract.ResetGasMetering(&_Vm.TransactOpts)
+}
+
+// ResetNonce is a paid mutator transaction binding the contract method 0x1c72346d.
+//
+// Solidity: function resetNonce(address account) returns()
+func (_Vm *VmTransactor) ResetNonce(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "resetNonce", account)
+}
+
+// ResetNonce is a paid mutator transaction binding the contract method 0x1c72346d.
+//
+// Solidity: function resetNonce(address account) returns()
+func (_Vm *VmSession) ResetNonce(account common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ResetNonce(&_Vm.TransactOpts, account)
+}
+
+// ResetNonce is a paid mutator transaction binding the contract method 0x1c72346d.
+//
+// Solidity: function resetNonce(address account) returns()
+func (_Vm *VmTransactorSession) ResetNonce(account common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.ResetNonce(&_Vm.TransactOpts, account)
+}
+
+// ResumeGasMetering is a paid mutator transaction binding the contract method 0x2bcd50e0.
+//
+// Solidity: function resumeGasMetering() returns()
+func (_Vm *VmTransactor) ResumeGasMetering(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "resumeGasMetering")
+}
+
+// ResumeGasMetering is a paid mutator transaction binding the contract method 0x2bcd50e0.
+//
+// Solidity: function resumeGasMetering() returns()
+func (_Vm *VmSession) ResumeGasMetering() (*types.Transaction, error) {
+	return _Vm.Contract.ResumeGasMetering(&_Vm.TransactOpts)
+}
+
+// ResumeGasMetering is a paid mutator transaction binding the contract method 0x2bcd50e0.
+//
+// Solidity: function resumeGasMetering() returns()
+func (_Vm *VmTransactorSession) ResumeGasMetering() (*types.Transaction, error) {
+	return _Vm.Contract.ResumeGasMetering(&_Vm.TransactOpts)
+}
+
+// RevertTo is a paid mutator transaction binding the contract method 0x44d7f0a4.
+//
+// Solidity: function revertTo(uint256 snapshotId) returns(bool success)
+func (_Vm *VmTransactor) RevertTo(opts *bind.TransactOpts, snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "revertTo", snapshotId)
+}
+
+// RevertTo is a paid mutator transaction binding the contract method 0x44d7f0a4.
+//
+// Solidity: function revertTo(uint256 snapshotId) returns(bool success)
+func (_Vm *VmSession) RevertTo(snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RevertTo(&_Vm.TransactOpts, snapshotId)
+}
+
+// RevertTo is a paid mutator transaction binding the contract method 0x44d7f0a4.
+//
+// Solidity: function revertTo(uint256 snapshotId) returns(bool success)
+func (_Vm *VmTransactorSession) RevertTo(snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RevertTo(&_Vm.TransactOpts, snapshotId)
+}
+
+// RevertToAndDelete is a paid mutator transaction binding the contract method 0x03e0aca9.
+//
+// Solidity: function revertToAndDelete(uint256 snapshotId) returns(bool success)
+func (_Vm *VmTransactor) RevertToAndDelete(opts *bind.TransactOpts, snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "revertToAndDelete", snapshotId)
+}
+
+// RevertToAndDelete is a paid mutator transaction binding the contract method 0x03e0aca9.
+//
+// Solidity: function revertToAndDelete(uint256 snapshotId) returns(bool success)
+func (_Vm *VmSession) RevertToAndDelete(snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RevertToAndDelete(&_Vm.TransactOpts, snapshotId)
+}
+
+// RevertToAndDelete is a paid mutator transaction binding the contract method 0x03e0aca9.
+//
+// Solidity: function revertToAndDelete(uint256 snapshotId) returns(bool success)
+func (_Vm *VmTransactorSession) RevertToAndDelete(snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RevertToAndDelete(&_Vm.TransactOpts, snapshotId)
+}
+
+// RevertToState is a paid mutator transaction binding the contract method 0xc2527405.
+//
+// Solidity: function revertToState(uint256 snapshotId) returns(bool success)
+func (_Vm *VmTransactor) RevertToState(opts *bind.TransactOpts, snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "revertToState", snapshotId)
+}
+
+// RevertToState is a paid mutator transaction binding the contract method 0xc2527405.
+//
+// Solidity: function revertToState(uint256 snapshotId) returns(bool success)
+func (_Vm *VmSession) RevertToState(snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RevertToState(&_Vm.TransactOpts, snapshotId)
+}
+
+// RevertToState is a paid mutator transaction binding the contract method 0xc2527405.
+//
+// Solidity: function revertToState(uint256 snapshotId) returns(bool success)
+func (_Vm *VmTransactorSession) RevertToState(snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RevertToState(&_Vm.TransactOpts, snapshotId)
+}
+
+// RevertToStateAndDelete is a paid mutator transaction binding the contract method 0x3a1985dc.
+//
+// Solidity: function revertToStateAndDelete(uint256 snapshotId) returns(bool success)
+func (_Vm *VmTransactor) RevertToStateAndDelete(opts *bind.TransactOpts, snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "revertToStateAndDelete", snapshotId)
+}
+
+// RevertToStateAndDelete is a paid mutator transaction binding the contract method 0x3a1985dc.
+//
+// Solidity: function revertToStateAndDelete(uint256 snapshotId) returns(bool success)
+func (_Vm *VmSession) RevertToStateAndDelete(snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RevertToStateAndDelete(&_Vm.TransactOpts, snapshotId)
+}
+
+// RevertToStateAndDelete is a paid mutator transaction binding the contract method 0x3a1985dc.
+//
+// Solidity: function revertToStateAndDelete(uint256 snapshotId) returns(bool success)
+func (_Vm *VmTransactorSession) RevertToStateAndDelete(snapshotId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RevertToStateAndDelete(&_Vm.TransactOpts, snapshotId)
+}
+
+// RevokePersistent is a paid mutator transaction binding the contract method 0x3ce969e6.
+//
+// Solidity: function revokePersistent(address[] accounts) returns()
+func (_Vm *VmTransactor) RevokePersistent(opts *bind.TransactOpts, accounts []common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "revokePersistent", accounts)
+}
+
+// RevokePersistent is a paid mutator transaction binding the contract method 0x3ce969e6.
+//
+// Solidity: function revokePersistent(address[] accounts) returns()
+func (_Vm *VmSession) RevokePersistent(accounts []common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.RevokePersistent(&_Vm.TransactOpts, accounts)
+}
+
+// RevokePersistent is a paid mutator transaction binding the contract method 0x3ce969e6.
+//
+// Solidity: function revokePersistent(address[] accounts) returns()
+func (_Vm *VmTransactorSession) RevokePersistent(accounts []common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.RevokePersistent(&_Vm.TransactOpts, accounts)
+}
+
+// RevokePersistent0 is a paid mutator transaction binding the contract method 0x997a0222.
+//
+// Solidity: function revokePersistent(address account) returns()
+func (_Vm *VmTransactor) RevokePersistent0(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "revokePersistent0", account)
+}
+
+// RevokePersistent0 is a paid mutator transaction binding the contract method 0x997a0222.
+//
+// Solidity: function revokePersistent(address account) returns()
+func (_Vm *VmSession) RevokePersistent0(account common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.RevokePersistent0(&_Vm.TransactOpts, account)
+}
+
+// RevokePersistent0 is a paid mutator transaction binding the contract method 0x997a0222.
+//
+// Solidity: function revokePersistent(address account) returns()
+func (_Vm *VmTransactorSession) RevokePersistent0(account common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.RevokePersistent0(&_Vm.TransactOpts, account)
+}
+
+// Roll is a paid mutator transaction binding the contract method 0x1f7b4f30.
+//
+// Solidity: function roll(uint256 newHeight) returns()
+func (_Vm *VmTransactor) Roll(opts *bind.TransactOpts, newHeight *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "roll", newHeight)
+}
+
+// Roll is a paid mutator transaction binding the contract method 0x1f7b4f30.
+//
+// Solidity: function roll(uint256 newHeight) returns()
+func (_Vm *VmSession) Roll(newHeight *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Roll(&_Vm.TransactOpts, newHeight)
+}
+
+// Roll is a paid mutator transaction binding the contract method 0x1f7b4f30.
+//
+// Solidity: function roll(uint256 newHeight) returns()
+func (_Vm *VmTransactorSession) Roll(newHeight *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Roll(&_Vm.TransactOpts, newHeight)
+}
+
+// RollFork is a paid mutator transaction binding the contract method 0x0f29772b.
+//
+// Solidity: function rollFork(bytes32 txHash) returns()
+func (_Vm *VmTransactor) RollFork(opts *bind.TransactOpts, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "rollFork", txHash)
+}
+
+// RollFork is a paid mutator transaction binding the contract method 0x0f29772b.
+//
+// Solidity: function rollFork(bytes32 txHash) returns()
+func (_Vm *VmSession) RollFork(txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.RollFork(&_Vm.TransactOpts, txHash)
+}
+
+// RollFork is a paid mutator transaction binding the contract method 0x0f29772b.
+//
+// Solidity: function rollFork(bytes32 txHash) returns()
+func (_Vm *VmTransactorSession) RollFork(txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.RollFork(&_Vm.TransactOpts, txHash)
+}
+
+// RollFork0 is a paid mutator transaction binding the contract method 0xd74c83a4.
+//
+// Solidity: function rollFork(uint256 forkId, uint256 blockNumber) returns()
+func (_Vm *VmTransactor) RollFork0(opts *bind.TransactOpts, forkId *big.Int, blockNumber *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "rollFork0", forkId, blockNumber)
+}
+
+// RollFork0 is a paid mutator transaction binding the contract method 0xd74c83a4.
+//
+// Solidity: function rollFork(uint256 forkId, uint256 blockNumber) returns()
+func (_Vm *VmSession) RollFork0(forkId *big.Int, blockNumber *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RollFork0(&_Vm.TransactOpts, forkId, blockNumber)
+}
+
+// RollFork0 is a paid mutator transaction binding the contract method 0xd74c83a4.
+//
+// Solidity: function rollFork(uint256 forkId, uint256 blockNumber) returns()
+func (_Vm *VmTransactorSession) RollFork0(forkId *big.Int, blockNumber *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RollFork0(&_Vm.TransactOpts, forkId, blockNumber)
+}
+
+// RollFork1 is a paid mutator transaction binding the contract method 0xd9bbf3a1.
+//
+// Solidity: function rollFork(uint256 blockNumber) returns()
+func (_Vm *VmTransactor) RollFork1(opts *bind.TransactOpts, blockNumber *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "rollFork1", blockNumber)
+}
+
+// RollFork1 is a paid mutator transaction binding the contract method 0xd9bbf3a1.
+//
+// Solidity: function rollFork(uint256 blockNumber) returns()
+func (_Vm *VmSession) RollFork1(blockNumber *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RollFork1(&_Vm.TransactOpts, blockNumber)
+}
+
+// RollFork1 is a paid mutator transaction binding the contract method 0xd9bbf3a1.
+//
+// Solidity: function rollFork(uint256 blockNumber) returns()
+func (_Vm *VmTransactorSession) RollFork1(blockNumber *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.RollFork1(&_Vm.TransactOpts, blockNumber)
+}
+
+// RollFork2 is a paid mutator transaction binding the contract method 0xf2830f7b.
+//
+// Solidity: function rollFork(uint256 forkId, bytes32 txHash) returns()
+func (_Vm *VmTransactor) RollFork2(opts *bind.TransactOpts, forkId *big.Int, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "rollFork2", forkId, txHash)
+}
+
+// RollFork2 is a paid mutator transaction binding the contract method 0xf2830f7b.
+//
+// Solidity: function rollFork(uint256 forkId, bytes32 txHash) returns()
+func (_Vm *VmSession) RollFork2(forkId *big.Int, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.RollFork2(&_Vm.TransactOpts, forkId, txHash)
+}
+
+// RollFork2 is a paid mutator transaction binding the contract method 0xf2830f7b.
+//
+// Solidity: function rollFork(uint256 forkId, bytes32 txHash) returns()
+func (_Vm *VmTransactorSession) RollFork2(forkId *big.Int, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.RollFork2(&_Vm.TransactOpts, forkId, txHash)
+}
+
+// Rpc is a paid mutator transaction binding the contract method 0x0199a220.
+//
+// Solidity: function rpc(string urlOrAlias, string method, string params) returns(bytes data)
+func (_Vm *VmTransactor) Rpc(opts *bind.TransactOpts, urlOrAlias string, method string, params string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "rpc", urlOrAlias, method, params)
+}
+
+// Rpc is a paid mutator transaction binding the contract method 0x0199a220.
+//
+// Solidity: function rpc(string urlOrAlias, string method, string params) returns(bytes data)
+func (_Vm *VmSession) Rpc(urlOrAlias string, method string, params string) (*types.Transaction, error) {
+	return _Vm.Contract.Rpc(&_Vm.TransactOpts, urlOrAlias, method, params)
+}
+
+// Rpc is a paid mutator transaction binding the contract method 0x0199a220.
+//
+// Solidity: function rpc(string urlOrAlias, string method, string params) returns(bytes data)
+func (_Vm *VmTransactorSession) Rpc(urlOrAlias string, method string, params string) (*types.Transaction, error) {
+	return _Vm.Contract.Rpc(&_Vm.TransactOpts, urlOrAlias, method, params)
+}
+
+// Rpc0 is a paid mutator transaction binding the contract method 0x1206c8a8.
+//
+// Solidity: function rpc(string method, string params) returns(bytes data)
+func (_Vm *VmTransactor) Rpc0(opts *bind.TransactOpts, method string, params string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "rpc0", method, params)
+}
+
+// Rpc0 is a paid mutator transaction binding the contract method 0x1206c8a8.
+//
+// Solidity: function rpc(string method, string params) returns(bytes data)
+func (_Vm *VmSession) Rpc0(method string, params string) (*types.Transaction, error) {
+	return _Vm.Contract.Rpc0(&_Vm.TransactOpts, method, params)
+}
+
+// Rpc0 is a paid mutator transaction binding the contract method 0x1206c8a8.
+//
+// Solidity: function rpc(string method, string params) returns(bytes data)
+func (_Vm *VmTransactorSession) Rpc0(method string, params string) (*types.Transaction, error) {
+	return _Vm.Contract.Rpc0(&_Vm.TransactOpts, method, params)
+}
+
+// SelectFork is a paid mutator transaction binding the contract method 0x9ebf6827.
+//
+// Solidity: function selectFork(uint256 forkId) returns()
+func (_Vm *VmTransactor) SelectFork(opts *bind.TransactOpts, forkId *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "selectFork", forkId)
+}
+
+// SelectFork is a paid mutator transaction binding the contract method 0x9ebf6827.
+//
+// Solidity: function selectFork(uint256 forkId) returns()
+func (_Vm *VmSession) SelectFork(forkId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SelectFork(&_Vm.TransactOpts, forkId)
+}
+
+// SelectFork is a paid mutator transaction binding the contract method 0x9ebf6827.
+//
+// Solidity: function selectFork(uint256 forkId) returns()
+func (_Vm *VmTransactorSession) SelectFork(forkId *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SelectFork(&_Vm.TransactOpts, forkId)
+}
+
+// SerializeAddress is a paid mutator transaction binding the contract method 0x1e356e1a.
+//
+// Solidity: function serializeAddress(string objectKey, string valueKey, address[] values) returns(string json)
+func (_Vm *VmTransactor) SerializeAddress(opts *bind.TransactOpts, objectKey string, valueKey string, values []common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeAddress", objectKey, valueKey, values)
+}
+
+// SerializeAddress is a paid mutator transaction binding the contract method 0x1e356e1a.
+//
+// Solidity: function serializeAddress(string objectKey, string valueKey, address[] values) returns(string json)
+func (_Vm *VmSession) SerializeAddress(objectKey string, valueKey string, values []common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeAddress(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeAddress is a paid mutator transaction binding the contract method 0x1e356e1a.
+//
+// Solidity: function serializeAddress(string objectKey, string valueKey, address[] values) returns(string json)
+func (_Vm *VmTransactorSession) SerializeAddress(objectKey string, valueKey string, values []common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeAddress(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeAddress0 is a paid mutator transaction binding the contract method 0x972c6062.
+//
+// Solidity: function serializeAddress(string objectKey, string valueKey, address value) returns(string json)
+func (_Vm *VmTransactor) SerializeAddress0(opts *bind.TransactOpts, objectKey string, valueKey string, value common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeAddress0", objectKey, valueKey, value)
+}
+
+// SerializeAddress0 is a paid mutator transaction binding the contract method 0x972c6062.
+//
+// Solidity: function serializeAddress(string objectKey, string valueKey, address value) returns(string json)
+func (_Vm *VmSession) SerializeAddress0(objectKey string, valueKey string, value common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeAddress0(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeAddress0 is a paid mutator transaction binding the contract method 0x972c6062.
+//
+// Solidity: function serializeAddress(string objectKey, string valueKey, address value) returns(string json)
+func (_Vm *VmTransactorSession) SerializeAddress0(objectKey string, valueKey string, value common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeAddress0(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeBool is a paid mutator transaction binding the contract method 0x92925aa1.
+//
+// Solidity: function serializeBool(string objectKey, string valueKey, bool[] values) returns(string json)
+func (_Vm *VmTransactor) SerializeBool(opts *bind.TransactOpts, objectKey string, valueKey string, values []bool) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeBool", objectKey, valueKey, values)
+}
+
+// SerializeBool is a paid mutator transaction binding the contract method 0x92925aa1.
+//
+// Solidity: function serializeBool(string objectKey, string valueKey, bool[] values) returns(string json)
+func (_Vm *VmSession) SerializeBool(objectKey string, valueKey string, values []bool) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeBool(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeBool is a paid mutator transaction binding the contract method 0x92925aa1.
+//
+// Solidity: function serializeBool(string objectKey, string valueKey, bool[] values) returns(string json)
+func (_Vm *VmTransactorSession) SerializeBool(objectKey string, valueKey string, values []bool) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeBool(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeBool0 is a paid mutator transaction binding the contract method 0xac22e971.
+//
+// Solidity: function serializeBool(string objectKey, string valueKey, bool value) returns(string json)
+func (_Vm *VmTransactor) SerializeBool0(opts *bind.TransactOpts, objectKey string, valueKey string, value bool) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeBool0", objectKey, valueKey, value)
+}
+
+// SerializeBool0 is a paid mutator transaction binding the contract method 0xac22e971.
+//
+// Solidity: function serializeBool(string objectKey, string valueKey, bool value) returns(string json)
+func (_Vm *VmSession) SerializeBool0(objectKey string, valueKey string, value bool) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeBool0(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeBool0 is a paid mutator transaction binding the contract method 0xac22e971.
+//
+// Solidity: function serializeBool(string objectKey, string valueKey, bool value) returns(string json)
+func (_Vm *VmTransactorSession) SerializeBool0(objectKey string, valueKey string, value bool) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeBool0(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeBytes is a paid mutator transaction binding the contract method 0x9884b232.
+//
+// Solidity: function serializeBytes(string objectKey, string valueKey, bytes[] values) returns(string json)
+func (_Vm *VmTransactor) SerializeBytes(opts *bind.TransactOpts, objectKey string, valueKey string, values [][]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeBytes", objectKey, valueKey, values)
+}
+
+// SerializeBytes is a paid mutator transaction binding the contract method 0x9884b232.
+//
+// Solidity: function serializeBytes(string objectKey, string valueKey, bytes[] values) returns(string json)
+func (_Vm *VmSession) SerializeBytes(objectKey string, valueKey string, values [][]byte) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeBytes(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeBytes is a paid mutator transaction binding the contract method 0x9884b232.
+//
+// Solidity: function serializeBytes(string objectKey, string valueKey, bytes[] values) returns(string json)
+func (_Vm *VmTransactorSession) SerializeBytes(objectKey string, valueKey string, values [][]byte) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeBytes(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeBytes0 is a paid mutator transaction binding the contract method 0xf21d52c7.
+//
+// Solidity: function serializeBytes(string objectKey, string valueKey, bytes value) returns(string json)
+func (_Vm *VmTransactor) SerializeBytes0(opts *bind.TransactOpts, objectKey string, valueKey string, value []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeBytes0", objectKey, valueKey, value)
+}
+
+// SerializeBytes0 is a paid mutator transaction binding the contract method 0xf21d52c7.
+//
+// Solidity: function serializeBytes(string objectKey, string valueKey, bytes value) returns(string json)
+func (_Vm *VmSession) SerializeBytes0(objectKey string, valueKey string, value []byte) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeBytes0(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeBytes0 is a paid mutator transaction binding the contract method 0xf21d52c7.
+//
+// Solidity: function serializeBytes(string objectKey, string valueKey, bytes value) returns(string json)
+func (_Vm *VmTransactorSession) SerializeBytes0(objectKey string, valueKey string, value []byte) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeBytes0(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeBytes32 is a paid mutator transaction binding the contract method 0x201e43e2.
+//
+// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32[] values) returns(string json)
+func (_Vm *VmTransactor) SerializeBytes32(opts *bind.TransactOpts, objectKey string, valueKey string, values [][32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeBytes32", objectKey, valueKey, values)
+}
+
+// SerializeBytes32 is a paid mutator transaction binding the contract method 0x201e43e2.
+//
+// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32[] values) returns(string json)
+func (_Vm *VmSession) SerializeBytes32(objectKey string, valueKey string, values [][32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeBytes32(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeBytes32 is a paid mutator transaction binding the contract method 0x201e43e2.
+//
+// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32[] values) returns(string json)
+func (_Vm *VmTransactorSession) SerializeBytes32(objectKey string, valueKey string, values [][32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeBytes32(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeBytes320 is a paid mutator transaction binding the contract method 0x2d812b44.
+//
+// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32 value) returns(string json)
+func (_Vm *VmTransactor) SerializeBytes320(opts *bind.TransactOpts, objectKey string, valueKey string, value [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeBytes320", objectKey, valueKey, value)
+}
+
+// SerializeBytes320 is a paid mutator transaction binding the contract method 0x2d812b44.
+//
+// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32 value) returns(string json)
+func (_Vm *VmSession) SerializeBytes320(objectKey string, valueKey string, value [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeBytes320(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeBytes320 is a paid mutator transaction binding the contract method 0x2d812b44.
+//
+// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32 value) returns(string json)
+func (_Vm *VmTransactorSession) SerializeBytes320(objectKey string, valueKey string, value [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeBytes320(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeInt is a paid mutator transaction binding the contract method 0x3f33db60.
+//
+// Solidity: function serializeInt(string objectKey, string valueKey, int256 value) returns(string json)
+func (_Vm *VmTransactor) SerializeInt(opts *bind.TransactOpts, objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeInt", objectKey, valueKey, value)
+}
+
+// SerializeInt is a paid mutator transaction binding the contract method 0x3f33db60.
+//
+// Solidity: function serializeInt(string objectKey, string valueKey, int256 value) returns(string json)
+func (_Vm *VmSession) SerializeInt(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeInt(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeInt is a paid mutator transaction binding the contract method 0x3f33db60.
+//
+// Solidity: function serializeInt(string objectKey, string valueKey, int256 value) returns(string json)
+func (_Vm *VmTransactorSession) SerializeInt(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeInt(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeInt0 is a paid mutator transaction binding the contract method 0x7676e127.
+//
+// Solidity: function serializeInt(string objectKey, string valueKey, int256[] values) returns(string json)
+func (_Vm *VmTransactor) SerializeInt0(opts *bind.TransactOpts, objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeInt0", objectKey, valueKey, values)
+}
+
+// SerializeInt0 is a paid mutator transaction binding the contract method 0x7676e127.
+//
+// Solidity: function serializeInt(string objectKey, string valueKey, int256[] values) returns(string json)
+func (_Vm *VmSession) SerializeInt0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeInt0(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeInt0 is a paid mutator transaction binding the contract method 0x7676e127.
+//
+// Solidity: function serializeInt(string objectKey, string valueKey, int256[] values) returns(string json)
+func (_Vm *VmTransactorSession) SerializeInt0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeInt0(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeJson is a paid mutator transaction binding the contract method 0x9b3358b0.
+//
+// Solidity: function serializeJson(string objectKey, string value) returns(string json)
+func (_Vm *VmTransactor) SerializeJson(opts *bind.TransactOpts, objectKey string, value string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeJson", objectKey, value)
+}
+
+// SerializeJson is a paid mutator transaction binding the contract method 0x9b3358b0.
+//
+// Solidity: function serializeJson(string objectKey, string value) returns(string json)
+func (_Vm *VmSession) SerializeJson(objectKey string, value string) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeJson(&_Vm.TransactOpts, objectKey, value)
+}
+
+// SerializeJson is a paid mutator transaction binding the contract method 0x9b3358b0.
+//
+// Solidity: function serializeJson(string objectKey, string value) returns(string json)
+func (_Vm *VmTransactorSession) SerializeJson(objectKey string, value string) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeJson(&_Vm.TransactOpts, objectKey, value)
+}
+
+// SerializeJsonType0 is a paid mutator transaction binding the contract method 0x6f93bccb.
+//
+// Solidity: function serializeJsonType(string objectKey, string valueKey, string typeDescription, bytes value) returns(string json)
+func (_Vm *VmTransactor) SerializeJsonType0(opts *bind.TransactOpts, objectKey string, valueKey string, typeDescription string, value []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeJsonType0", objectKey, valueKey, typeDescription, value)
+}
+
+// SerializeJsonType0 is a paid mutator transaction binding the contract method 0x6f93bccb.
+//
+// Solidity: function serializeJsonType(string objectKey, string valueKey, string typeDescription, bytes value) returns(string json)
+func (_Vm *VmSession) SerializeJsonType0(objectKey string, valueKey string, typeDescription string, value []byte) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeJsonType0(&_Vm.TransactOpts, objectKey, valueKey, typeDescription, value)
+}
+
+// SerializeJsonType0 is a paid mutator transaction binding the contract method 0x6f93bccb.
+//
+// Solidity: function serializeJsonType(string objectKey, string valueKey, string typeDescription, bytes value) returns(string json)
+func (_Vm *VmTransactorSession) SerializeJsonType0(objectKey string, valueKey string, typeDescription string, value []byte) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeJsonType0(&_Vm.TransactOpts, objectKey, valueKey, typeDescription, value)
+}
+
+// SerializeString is a paid mutator transaction binding the contract method 0x561cd6f3.
+//
+// Solidity: function serializeString(string objectKey, string valueKey, string[] values) returns(string json)
+func (_Vm *VmTransactor) SerializeString(opts *bind.TransactOpts, objectKey string, valueKey string, values []string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeString", objectKey, valueKey, values)
+}
+
+// SerializeString is a paid mutator transaction binding the contract method 0x561cd6f3.
+//
+// Solidity: function serializeString(string objectKey, string valueKey, string[] values) returns(string json)
+func (_Vm *VmSession) SerializeString(objectKey string, valueKey string, values []string) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeString(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeString is a paid mutator transaction binding the contract method 0x561cd6f3.
+//
+// Solidity: function serializeString(string objectKey, string valueKey, string[] values) returns(string json)
+func (_Vm *VmTransactorSession) SerializeString(objectKey string, valueKey string, values []string) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeString(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeString0 is a paid mutator transaction binding the contract method 0x88da6d35.
+//
+// Solidity: function serializeString(string objectKey, string valueKey, string value) returns(string json)
+func (_Vm *VmTransactor) SerializeString0(opts *bind.TransactOpts, objectKey string, valueKey string, value string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeString0", objectKey, valueKey, value)
+}
+
+// SerializeString0 is a paid mutator transaction binding the contract method 0x88da6d35.
+//
+// Solidity: function serializeString(string objectKey, string valueKey, string value) returns(string json)
+func (_Vm *VmSession) SerializeString0(objectKey string, valueKey string, value string) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeString0(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeString0 is a paid mutator transaction binding the contract method 0x88da6d35.
+//
+// Solidity: function serializeString(string objectKey, string valueKey, string value) returns(string json)
+func (_Vm *VmTransactorSession) SerializeString0(objectKey string, valueKey string, value string) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeString0(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeUint is a paid mutator transaction binding the contract method 0x129e9002.
+//
+// Solidity: function serializeUint(string objectKey, string valueKey, uint256 value) returns(string json)
+func (_Vm *VmTransactor) SerializeUint(opts *bind.TransactOpts, objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeUint", objectKey, valueKey, value)
+}
+
+// SerializeUint is a paid mutator transaction binding the contract method 0x129e9002.
+//
+// Solidity: function serializeUint(string objectKey, string valueKey, uint256 value) returns(string json)
+func (_Vm *VmSession) SerializeUint(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeUint(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeUint is a paid mutator transaction binding the contract method 0x129e9002.
+//
+// Solidity: function serializeUint(string objectKey, string valueKey, uint256 value) returns(string json)
+func (_Vm *VmTransactorSession) SerializeUint(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeUint(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeUint0 is a paid mutator transaction binding the contract method 0xfee9a469.
+//
+// Solidity: function serializeUint(string objectKey, string valueKey, uint256[] values) returns(string json)
+func (_Vm *VmTransactor) SerializeUint0(opts *bind.TransactOpts, objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeUint0", objectKey, valueKey, values)
+}
+
+// SerializeUint0 is a paid mutator transaction binding the contract method 0xfee9a469.
+//
+// Solidity: function serializeUint(string objectKey, string valueKey, uint256[] values) returns(string json)
+func (_Vm *VmSession) SerializeUint0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeUint0(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeUint0 is a paid mutator transaction binding the contract method 0xfee9a469.
+//
+// Solidity: function serializeUint(string objectKey, string valueKey, uint256[] values) returns(string json)
+func (_Vm *VmTransactorSession) SerializeUint0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeUint0(&_Vm.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeUintToHex is a paid mutator transaction binding the contract method 0xae5a2ae8.
+//
+// Solidity: function serializeUintToHex(string objectKey, string valueKey, uint256 value) returns(string json)
+func (_Vm *VmTransactor) SerializeUintToHex(opts *bind.TransactOpts, objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "serializeUintToHex", objectKey, valueKey, value)
+}
+
+// SerializeUintToHex is a paid mutator transaction binding the contract method 0xae5a2ae8.
+//
+// Solidity: function serializeUintToHex(string objectKey, string valueKey, uint256 value) returns(string json)
+func (_Vm *VmSession) SerializeUintToHex(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeUintToHex(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeUintToHex is a paid mutator transaction binding the contract method 0xae5a2ae8.
+//
+// Solidity: function serializeUintToHex(string objectKey, string valueKey, uint256 value) returns(string json)
+func (_Vm *VmTransactorSession) SerializeUintToHex(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SerializeUintToHex(&_Vm.TransactOpts, objectKey, valueKey, value)
+}
+
+// SetArbitraryStorage is a paid mutator transaction binding the contract method 0xe1631837.
+//
+// Solidity: function setArbitraryStorage(address target) returns()
+func (_Vm *VmTransactor) SetArbitraryStorage(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "setArbitraryStorage", target)
+}
+
+// SetArbitraryStorage is a paid mutator transaction binding the contract method 0xe1631837.
+//
+// Solidity: function setArbitraryStorage(address target) returns()
+func (_Vm *VmSession) SetArbitraryStorage(target common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.SetArbitraryStorage(&_Vm.TransactOpts, target)
+}
+
+// SetArbitraryStorage is a paid mutator transaction binding the contract method 0xe1631837.
+//
+// Solidity: function setArbitraryStorage(address target) returns()
+func (_Vm *VmTransactorSession) SetArbitraryStorage(target common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.SetArbitraryStorage(&_Vm.TransactOpts, target)
+}
+
+// SetBlockhash is a paid mutator transaction binding the contract method 0x5314b54a.
+//
+// Solidity: function setBlockhash(uint256 blockNumber, bytes32 blockHash) returns()
+func (_Vm *VmTransactor) SetBlockhash(opts *bind.TransactOpts, blockNumber *big.Int, blockHash [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "setBlockhash", blockNumber, blockHash)
+}
+
+// SetBlockhash is a paid mutator transaction binding the contract method 0x5314b54a.
+//
+// Solidity: function setBlockhash(uint256 blockNumber, bytes32 blockHash) returns()
+func (_Vm *VmSession) SetBlockhash(blockNumber *big.Int, blockHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.SetBlockhash(&_Vm.TransactOpts, blockNumber, blockHash)
+}
+
+// SetBlockhash is a paid mutator transaction binding the contract method 0x5314b54a.
+//
+// Solidity: function setBlockhash(uint256 blockNumber, bytes32 blockHash) returns()
+func (_Vm *VmTransactorSession) SetBlockhash(blockNumber *big.Int, blockHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.SetBlockhash(&_Vm.TransactOpts, blockNumber, blockHash)
+}
+
+// SetEnv is a paid mutator transaction binding the contract method 0x3d5923ee.
+//
+// Solidity: function setEnv(string name, string value) returns()
+func (_Vm *VmTransactor) SetEnv(opts *bind.TransactOpts, name string, value string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "setEnv", name, value)
+}
+
+// SetEnv is a paid mutator transaction binding the contract method 0x3d5923ee.
+//
+// Solidity: function setEnv(string name, string value) returns()
+func (_Vm *VmSession) SetEnv(name string, value string) (*types.Transaction, error) {
+	return _Vm.Contract.SetEnv(&_Vm.TransactOpts, name, value)
+}
+
+// SetEnv is a paid mutator transaction binding the contract method 0x3d5923ee.
+//
+// Solidity: function setEnv(string name, string value) returns()
+func (_Vm *VmTransactorSession) SetEnv(name string, value string) (*types.Transaction, error) {
+	return _Vm.Contract.SetEnv(&_Vm.TransactOpts, name, value)
+}
+
+// SetNonce is a paid mutator transaction binding the contract method 0xf8e18b57.
+//
+// Solidity: function setNonce(address account, uint64 newNonce) returns()
+func (_Vm *VmTransactor) SetNonce(opts *bind.TransactOpts, account common.Address, newNonce uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "setNonce", account, newNonce)
+}
+
+// SetNonce is a paid mutator transaction binding the contract method 0xf8e18b57.
+//
+// Solidity: function setNonce(address account, uint64 newNonce) returns()
+func (_Vm *VmSession) SetNonce(account common.Address, newNonce uint64) (*types.Transaction, error) {
+	return _Vm.Contract.SetNonce(&_Vm.TransactOpts, account, newNonce)
+}
+
+// SetNonce is a paid mutator transaction binding the contract method 0xf8e18b57.
+//
+// Solidity: function setNonce(address account, uint64 newNonce) returns()
+func (_Vm *VmTransactorSession) SetNonce(account common.Address, newNonce uint64) (*types.Transaction, error) {
+	return _Vm.Contract.SetNonce(&_Vm.TransactOpts, account, newNonce)
+}
+
+// SetNonceUnsafe is a paid mutator transaction binding the contract method 0x9b67b21c.
+//
+// Solidity: function setNonceUnsafe(address account, uint64 newNonce) returns()
+func (_Vm *VmTransactor) SetNonceUnsafe(opts *bind.TransactOpts, account common.Address, newNonce uint64) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "setNonceUnsafe", account, newNonce)
+}
+
+// SetNonceUnsafe is a paid mutator transaction binding the contract method 0x9b67b21c.
+//
+// Solidity: function setNonceUnsafe(address account, uint64 newNonce) returns()
+func (_Vm *VmSession) SetNonceUnsafe(account common.Address, newNonce uint64) (*types.Transaction, error) {
+	return _Vm.Contract.SetNonceUnsafe(&_Vm.TransactOpts, account, newNonce)
+}
+
+// SetNonceUnsafe is a paid mutator transaction binding the contract method 0x9b67b21c.
+//
+// Solidity: function setNonceUnsafe(address account, uint64 newNonce) returns()
+func (_Vm *VmTransactorSession) SetNonceUnsafe(account common.Address, newNonce uint64) (*types.Transaction, error) {
+	return _Vm.Contract.SetNonceUnsafe(&_Vm.TransactOpts, account, newNonce)
+}
+
+// Sign1 is a paid mutator transaction binding the contract method 0xb25c5a25.
+//
+// Solidity: function sign((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(uint8 v, bytes32 r, bytes32 s)
+func (_Vm *VmTransactor) Sign1(opts *bind.TransactOpts, wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "sign1", wallet, digest)
+}
+
+// Sign1 is a paid mutator transaction binding the contract method 0xb25c5a25.
+//
+// Solidity: function sign((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(uint8 v, bytes32 r, bytes32 s)
+func (_Vm *VmSession) Sign1(wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.Sign1(&_Vm.TransactOpts, wallet, digest)
+}
+
+// Sign1 is a paid mutator transaction binding the contract method 0xb25c5a25.
+//
+// Solidity: function sign((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(uint8 v, bytes32 r, bytes32 s)
+func (_Vm *VmTransactorSession) Sign1(wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.Sign1(&_Vm.TransactOpts, wallet, digest)
+}
+
+// SignAndAttachDelegation is a paid mutator transaction binding the contract method 0xc7fa7288.
+//
+// Solidity: function signAndAttachDelegation(address implementation, uint256 privateKey) returns((uint8,bytes32,bytes32,uint64,address) signedDelegation)
+func (_Vm *VmTransactor) SignAndAttachDelegation(opts *bind.TransactOpts, implementation common.Address, privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "signAndAttachDelegation", implementation, privateKey)
+}
+
+// SignAndAttachDelegation is a paid mutator transaction binding the contract method 0xc7fa7288.
+//
+// Solidity: function signAndAttachDelegation(address implementation, uint256 privateKey) returns((uint8,bytes32,bytes32,uint64,address) signedDelegation)
+func (_Vm *VmSession) SignAndAttachDelegation(implementation common.Address, privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SignAndAttachDelegation(&_Vm.TransactOpts, implementation, privateKey)
+}
+
+// SignAndAttachDelegation is a paid mutator transaction binding the contract method 0xc7fa7288.
+//
+// Solidity: function signAndAttachDelegation(address implementation, uint256 privateKey) returns((uint8,bytes32,bytes32,uint64,address) signedDelegation)
+func (_Vm *VmTransactorSession) SignAndAttachDelegation(implementation common.Address, privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SignAndAttachDelegation(&_Vm.TransactOpts, implementation, privateKey)
+}
+
+// SignCompact is a paid mutator transaction binding the contract method 0x3d0e292f.
+//
+// Solidity: function signCompact((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(bytes32 r, bytes32 vs)
+func (_Vm *VmTransactor) SignCompact(opts *bind.TransactOpts, wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "signCompact", wallet, digest)
+}
+
+// SignCompact is a paid mutator transaction binding the contract method 0x3d0e292f.
+//
+// Solidity: function signCompact((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(bytes32 r, bytes32 vs)
+func (_Vm *VmSession) SignCompact(wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.SignCompact(&_Vm.TransactOpts, wallet, digest)
+}
+
+// SignCompact is a paid mutator transaction binding the contract method 0x3d0e292f.
+//
+// Solidity: function signCompact((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(bytes32 r, bytes32 vs)
+func (_Vm *VmTransactorSession) SignCompact(wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.SignCompact(&_Vm.TransactOpts, wallet, digest)
+}
+
+// SignDelegation is a paid mutator transaction binding the contract method 0x5b593c7b.
+//
+// Solidity: function signDelegation(address implementation, uint256 privateKey) returns((uint8,bytes32,bytes32,uint64,address) signedDelegation)
+func (_Vm *VmTransactor) SignDelegation(opts *bind.TransactOpts, implementation common.Address, privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "signDelegation", implementation, privateKey)
+}
+
+// SignDelegation is a paid mutator transaction binding the contract method 0x5b593c7b.
+//
+// Solidity: function signDelegation(address implementation, uint256 privateKey) returns((uint8,bytes32,bytes32,uint64,address) signedDelegation)
+func (_Vm *VmSession) SignDelegation(implementation common.Address, privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SignDelegation(&_Vm.TransactOpts, implementation, privateKey)
+}
+
+// SignDelegation is a paid mutator transaction binding the contract method 0x5b593c7b.
+//
+// Solidity: function signDelegation(address implementation, uint256 privateKey) returns((uint8,bytes32,bytes32,uint64,address) signedDelegation)
+func (_Vm *VmTransactorSession) SignDelegation(implementation common.Address, privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SignDelegation(&_Vm.TransactOpts, implementation, privateKey)
+}
+
+// Skip is a paid mutator transaction binding the contract method 0xc42a80a7.
+//
+// Solidity: function skip(bool skipTest, string reason) returns()
+func (_Vm *VmTransactor) Skip(opts *bind.TransactOpts, skipTest bool, reason string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "skip", skipTest, reason)
+}
+
+// Skip is a paid mutator transaction binding the contract method 0xc42a80a7.
+//
+// Solidity: function skip(bool skipTest, string reason) returns()
+func (_Vm *VmSession) Skip(skipTest bool, reason string) (*types.Transaction, error) {
+	return _Vm.Contract.Skip(&_Vm.TransactOpts, skipTest, reason)
+}
+
+// Skip is a paid mutator transaction binding the contract method 0xc42a80a7.
+//
+// Solidity: function skip(bool skipTest, string reason) returns()
+func (_Vm *VmTransactorSession) Skip(skipTest bool, reason string) (*types.Transaction, error) {
+	return _Vm.Contract.Skip(&_Vm.TransactOpts, skipTest, reason)
+}
+
+// Skip0 is a paid mutator transaction binding the contract method 0xdd82d13e.
+//
+// Solidity: function skip(bool skipTest) returns()
+func (_Vm *VmTransactor) Skip0(opts *bind.TransactOpts, skipTest bool) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "skip0", skipTest)
+}
+
+// Skip0 is a paid mutator transaction binding the contract method 0xdd82d13e.
+//
+// Solidity: function skip(bool skipTest) returns()
+func (_Vm *VmSession) Skip0(skipTest bool) (*types.Transaction, error) {
+	return _Vm.Contract.Skip0(&_Vm.TransactOpts, skipTest)
+}
+
+// Skip0 is a paid mutator transaction binding the contract method 0xdd82d13e.
+//
+// Solidity: function skip(bool skipTest) returns()
+func (_Vm *VmTransactorSession) Skip0(skipTest bool) (*types.Transaction, error) {
+	return _Vm.Contract.Skip0(&_Vm.TransactOpts, skipTest)
+}
+
+// Sleep is a paid mutator transaction binding the contract method 0xfa9d8713.
+//
+// Solidity: function sleep(uint256 duration) returns()
+func (_Vm *VmTransactor) Sleep(opts *bind.TransactOpts, duration *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "sleep", duration)
+}
+
+// Sleep is a paid mutator transaction binding the contract method 0xfa9d8713.
+//
+// Solidity: function sleep(uint256 duration) returns()
+func (_Vm *VmSession) Sleep(duration *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Sleep(&_Vm.TransactOpts, duration)
+}
+
+// Sleep is a paid mutator transaction binding the contract method 0xfa9d8713.
+//
+// Solidity: function sleep(uint256 duration) returns()
+func (_Vm *VmTransactorSession) Sleep(duration *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Sleep(&_Vm.TransactOpts, duration)
+}
+
+// Snapshot is a paid mutator transaction binding the contract method 0x9711715a.
+//
+// Solidity: function snapshot() returns(uint256 snapshotId)
+func (_Vm *VmTransactor) Snapshot(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "snapshot")
+}
+
+// Snapshot is a paid mutator transaction binding the contract method 0x9711715a.
+//
+// Solidity: function snapshot() returns(uint256 snapshotId)
+func (_Vm *VmSession) Snapshot() (*types.Transaction, error) {
+	return _Vm.Contract.Snapshot(&_Vm.TransactOpts)
+}
+
+// Snapshot is a paid mutator transaction binding the contract method 0x9711715a.
+//
+// Solidity: function snapshot() returns(uint256 snapshotId)
+func (_Vm *VmTransactorSession) Snapshot() (*types.Transaction, error) {
+	return _Vm.Contract.Snapshot(&_Vm.TransactOpts)
+}
+
+// SnapshotGasLastCall is a paid mutator transaction binding the contract method 0x200c6772.
+//
+// Solidity: function snapshotGasLastCall(string group, string name) returns(uint256 gasUsed)
+func (_Vm *VmTransactor) SnapshotGasLastCall(opts *bind.TransactOpts, group string, name string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "snapshotGasLastCall", group, name)
+}
+
+// SnapshotGasLastCall is a paid mutator transaction binding the contract method 0x200c6772.
+//
+// Solidity: function snapshotGasLastCall(string group, string name) returns(uint256 gasUsed)
+func (_Vm *VmSession) SnapshotGasLastCall(group string, name string) (*types.Transaction, error) {
+	return _Vm.Contract.SnapshotGasLastCall(&_Vm.TransactOpts, group, name)
+}
+
+// SnapshotGasLastCall is a paid mutator transaction binding the contract method 0x200c6772.
+//
+// Solidity: function snapshotGasLastCall(string group, string name) returns(uint256 gasUsed)
+func (_Vm *VmTransactorSession) SnapshotGasLastCall(group string, name string) (*types.Transaction, error) {
+	return _Vm.Contract.SnapshotGasLastCall(&_Vm.TransactOpts, group, name)
+}
+
+// SnapshotGasLastCall0 is a paid mutator transaction binding the contract method 0xdd9fca12.
+//
+// Solidity: function snapshotGasLastCall(string name) returns(uint256 gasUsed)
+func (_Vm *VmTransactor) SnapshotGasLastCall0(opts *bind.TransactOpts, name string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "snapshotGasLastCall0", name)
+}
+
+// SnapshotGasLastCall0 is a paid mutator transaction binding the contract method 0xdd9fca12.
+//
+// Solidity: function snapshotGasLastCall(string name) returns(uint256 gasUsed)
+func (_Vm *VmSession) SnapshotGasLastCall0(name string) (*types.Transaction, error) {
+	return _Vm.Contract.SnapshotGasLastCall0(&_Vm.TransactOpts, name)
+}
+
+// SnapshotGasLastCall0 is a paid mutator transaction binding the contract method 0xdd9fca12.
+//
+// Solidity: function snapshotGasLastCall(string name) returns(uint256 gasUsed)
+func (_Vm *VmTransactorSession) SnapshotGasLastCall0(name string) (*types.Transaction, error) {
+	return _Vm.Contract.SnapshotGasLastCall0(&_Vm.TransactOpts, name)
+}
+
+// SnapshotState is a paid mutator transaction binding the contract method 0x9cd23835.
+//
+// Solidity: function snapshotState() returns(uint256 snapshotId)
+func (_Vm *VmTransactor) SnapshotState(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "snapshotState")
+}
+
+// SnapshotState is a paid mutator transaction binding the contract method 0x9cd23835.
+//
+// Solidity: function snapshotState() returns(uint256 snapshotId)
+func (_Vm *VmSession) SnapshotState() (*types.Transaction, error) {
+	return _Vm.Contract.SnapshotState(&_Vm.TransactOpts)
+}
+
+// SnapshotState is a paid mutator transaction binding the contract method 0x9cd23835.
+//
+// Solidity: function snapshotState() returns(uint256 snapshotId)
+func (_Vm *VmTransactorSession) SnapshotState() (*types.Transaction, error) {
+	return _Vm.Contract.SnapshotState(&_Vm.TransactOpts)
+}
+
+// SnapshotValue is a paid mutator transaction binding the contract method 0x51db805a.
+//
+// Solidity: function snapshotValue(string name, uint256 value) returns()
+func (_Vm *VmTransactor) SnapshotValue(opts *bind.TransactOpts, name string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "snapshotValue", name, value)
+}
+
+// SnapshotValue is a paid mutator transaction binding the contract method 0x51db805a.
+//
+// Solidity: function snapshotValue(string name, uint256 value) returns()
+func (_Vm *VmSession) SnapshotValue(name string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SnapshotValue(&_Vm.TransactOpts, name, value)
+}
+
+// SnapshotValue is a paid mutator transaction binding the contract method 0x51db805a.
+//
+// Solidity: function snapshotValue(string name, uint256 value) returns()
+func (_Vm *VmTransactorSession) SnapshotValue(name string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SnapshotValue(&_Vm.TransactOpts, name, value)
+}
+
+// SnapshotValue0 is a paid mutator transaction binding the contract method 0x6d2b27d8.
+//
+// Solidity: function snapshotValue(string group, string name, uint256 value) returns()
+func (_Vm *VmTransactor) SnapshotValue0(opts *bind.TransactOpts, group string, name string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "snapshotValue0", group, name, value)
+}
+
+// SnapshotValue0 is a paid mutator transaction binding the contract method 0x6d2b27d8.
+//
+// Solidity: function snapshotValue(string group, string name, uint256 value) returns()
+func (_Vm *VmSession) SnapshotValue0(group string, name string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SnapshotValue0(&_Vm.TransactOpts, group, name, value)
+}
+
+// SnapshotValue0 is a paid mutator transaction binding the contract method 0x6d2b27d8.
+//
+// Solidity: function snapshotValue(string group, string name, uint256 value) returns()
+func (_Vm *VmTransactorSession) SnapshotValue0(group string, name string, value *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.SnapshotValue0(&_Vm.TransactOpts, group, name, value)
+}
+
+// StartBroadcast is a paid mutator transaction binding the contract method 0x7fb5297f.
+//
+// Solidity: function startBroadcast() returns()
+func (_Vm *VmTransactor) StartBroadcast(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "startBroadcast")
+}
+
+// StartBroadcast is a paid mutator transaction binding the contract method 0x7fb5297f.
+//
+// Solidity: function startBroadcast() returns()
+func (_Vm *VmSession) StartBroadcast() (*types.Transaction, error) {
+	return _Vm.Contract.StartBroadcast(&_Vm.TransactOpts)
+}
+
+// StartBroadcast is a paid mutator transaction binding the contract method 0x7fb5297f.
+//
+// Solidity: function startBroadcast() returns()
+func (_Vm *VmTransactorSession) StartBroadcast() (*types.Transaction, error) {
+	return _Vm.Contract.StartBroadcast(&_Vm.TransactOpts)
+}
+
+// StartBroadcast0 is a paid mutator transaction binding the contract method 0x7fec2a8d.
+//
+// Solidity: function startBroadcast(address signer) returns()
+func (_Vm *VmTransactor) StartBroadcast0(opts *bind.TransactOpts, signer common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "startBroadcast0", signer)
+}
+
+// StartBroadcast0 is a paid mutator transaction binding the contract method 0x7fec2a8d.
+//
+// Solidity: function startBroadcast(address signer) returns()
+func (_Vm *VmSession) StartBroadcast0(signer common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.StartBroadcast0(&_Vm.TransactOpts, signer)
+}
+
+// StartBroadcast0 is a paid mutator transaction binding the contract method 0x7fec2a8d.
+//
+// Solidity: function startBroadcast(address signer) returns()
+func (_Vm *VmTransactorSession) StartBroadcast0(signer common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.StartBroadcast0(&_Vm.TransactOpts, signer)
+}
+
+// StartBroadcast1 is a paid mutator transaction binding the contract method 0xce817d47.
+//
+// Solidity: function startBroadcast(uint256 privateKey) returns()
+func (_Vm *VmTransactor) StartBroadcast1(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "startBroadcast1", privateKey)
+}
+
+// StartBroadcast1 is a paid mutator transaction binding the contract method 0xce817d47.
+//
+// Solidity: function startBroadcast(uint256 privateKey) returns()
+func (_Vm *VmSession) StartBroadcast1(privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.StartBroadcast1(&_Vm.TransactOpts, privateKey)
+}
+
+// StartBroadcast1 is a paid mutator transaction binding the contract method 0xce817d47.
+//
+// Solidity: function startBroadcast(uint256 privateKey) returns()
+func (_Vm *VmTransactorSession) StartBroadcast1(privateKey *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.StartBroadcast1(&_Vm.TransactOpts, privateKey)
+}
+
+// StartDebugTraceRecording is a paid mutator transaction binding the contract method 0x419c8832.
+//
+// Solidity: function startDebugTraceRecording() returns()
+func (_Vm *VmTransactor) StartDebugTraceRecording(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "startDebugTraceRecording")
+}
+
+// StartDebugTraceRecording is a paid mutator transaction binding the contract method 0x419c8832.
+//
+// Solidity: function startDebugTraceRecording() returns()
+func (_Vm *VmSession) StartDebugTraceRecording() (*types.Transaction, error) {
+	return _Vm.Contract.StartDebugTraceRecording(&_Vm.TransactOpts)
+}
+
+// StartDebugTraceRecording is a paid mutator transaction binding the contract method 0x419c8832.
+//
+// Solidity: function startDebugTraceRecording() returns()
+func (_Vm *VmTransactorSession) StartDebugTraceRecording() (*types.Transaction, error) {
+	return _Vm.Contract.StartDebugTraceRecording(&_Vm.TransactOpts)
+}
+
+// StartMappingRecording is a paid mutator transaction binding the contract method 0x3e9705c0.
+//
+// Solidity: function startMappingRecording() returns()
+func (_Vm *VmTransactor) StartMappingRecording(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "startMappingRecording")
+}
+
+// StartMappingRecording is a paid mutator transaction binding the contract method 0x3e9705c0.
+//
+// Solidity: function startMappingRecording() returns()
+func (_Vm *VmSession) StartMappingRecording() (*types.Transaction, error) {
+	return _Vm.Contract.StartMappingRecording(&_Vm.TransactOpts)
+}
+
+// StartMappingRecording is a paid mutator transaction binding the contract method 0x3e9705c0.
+//
+// Solidity: function startMappingRecording() returns()
+func (_Vm *VmTransactorSession) StartMappingRecording() (*types.Transaction, error) {
+	return _Vm.Contract.StartMappingRecording(&_Vm.TransactOpts)
+}
+
+// StartPrank is a paid mutator transaction binding the contract method 0x06447d56.
+//
+// Solidity: function startPrank(address msgSender) returns()
+func (_Vm *VmTransactor) StartPrank(opts *bind.TransactOpts, msgSender common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "startPrank", msgSender)
+}
+
+// StartPrank is a paid mutator transaction binding the contract method 0x06447d56.
+//
+// Solidity: function startPrank(address msgSender) returns()
+func (_Vm *VmSession) StartPrank(msgSender common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.StartPrank(&_Vm.TransactOpts, msgSender)
+}
+
+// StartPrank is a paid mutator transaction binding the contract method 0x06447d56.
+//
+// Solidity: function startPrank(address msgSender) returns()
+func (_Vm *VmTransactorSession) StartPrank(msgSender common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.StartPrank(&_Vm.TransactOpts, msgSender)
+}
+
+// StartPrank0 is a paid mutator transaction binding the contract method 0x1cc0b435.
+//
+// Solidity: function startPrank(address msgSender, bool delegateCall) returns()
+func (_Vm *VmTransactor) StartPrank0(opts *bind.TransactOpts, msgSender common.Address, delegateCall bool) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "startPrank0", msgSender, delegateCall)
+}
+
+// StartPrank0 is a paid mutator transaction binding the contract method 0x1cc0b435.
+//
+// Solidity: function startPrank(address msgSender, bool delegateCall) returns()
+func (_Vm *VmSession) StartPrank0(msgSender common.Address, delegateCall bool) (*types.Transaction, error) {
+	return _Vm.Contract.StartPrank0(&_Vm.TransactOpts, msgSender, delegateCall)
+}
+
+// StartPrank0 is a paid mutator transaction binding the contract method 0x1cc0b435.
+//
+// Solidity: function startPrank(address msgSender, bool delegateCall) returns()
+func (_Vm *VmTransactorSession) StartPrank0(msgSender common.Address, delegateCall bool) (*types.Transaction, error) {
+	return _Vm.Contract.StartPrank0(&_Vm.TransactOpts, msgSender, delegateCall)
+}
+
+// StartPrank1 is a paid mutator transaction binding the contract method 0x45b56078.
+//
+// Solidity: function startPrank(address msgSender, address txOrigin) returns()
+func (_Vm *VmTransactor) StartPrank1(opts *bind.TransactOpts, msgSender common.Address, txOrigin common.Address) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "startPrank1", msgSender, txOrigin)
+}
+
+// StartPrank1 is a paid mutator transaction binding the contract method 0x45b56078.
+//
+// Solidity: function startPrank(address msgSender, address txOrigin) returns()
+func (_Vm *VmSession) StartPrank1(msgSender common.Address, txOrigin common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.StartPrank1(&_Vm.TransactOpts, msgSender, txOrigin)
+}
+
+// StartPrank1 is a paid mutator transaction binding the contract method 0x45b56078.
+//
+// Solidity: function startPrank(address msgSender, address txOrigin) returns()
+func (_Vm *VmTransactorSession) StartPrank1(msgSender common.Address, txOrigin common.Address) (*types.Transaction, error) {
+	return _Vm.Contract.StartPrank1(&_Vm.TransactOpts, msgSender, txOrigin)
+}
+
+// StartPrank2 is a paid mutator transaction binding the contract method 0x4eb859b5.
+//
+// Solidity: function startPrank(address msgSender, address txOrigin, bool delegateCall) returns()
+func (_Vm *VmTransactor) StartPrank2(opts *bind.TransactOpts, msgSender common.Address, txOrigin common.Address, delegateCall bool) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "startPrank2", msgSender, txOrigin, delegateCall)
+}
+
+// StartPrank2 is a paid mutator transaction binding the contract method 0x4eb859b5.
+//
+// Solidity: function startPrank(address msgSender, address txOrigin, bool delegateCall) returns()
+func (_Vm *VmSession) StartPrank2(msgSender common.Address, txOrigin common.Address, delegateCall bool) (*types.Transaction, error) {
+	return _Vm.Contract.StartPrank2(&_Vm.TransactOpts, msgSender, txOrigin, delegateCall)
+}
+
+// StartPrank2 is a paid mutator transaction binding the contract method 0x4eb859b5.
+//
+// Solidity: function startPrank(address msgSender, address txOrigin, bool delegateCall) returns()
+func (_Vm *VmTransactorSession) StartPrank2(msgSender common.Address, txOrigin common.Address, delegateCall bool) (*types.Transaction, error) {
+	return _Vm.Contract.StartPrank2(&_Vm.TransactOpts, msgSender, txOrigin, delegateCall)
+}
+
+// StartSnapshotGas is a paid mutator transaction binding the contract method 0x3cad9d7b.
+//
+// Solidity: function startSnapshotGas(string name) returns()
+func (_Vm *VmTransactor) StartSnapshotGas(opts *bind.TransactOpts, name string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "startSnapshotGas", name)
+}
+
+// StartSnapshotGas is a paid mutator transaction binding the contract method 0x3cad9d7b.
+//
+// Solidity: function startSnapshotGas(string name) returns()
+func (_Vm *VmSession) StartSnapshotGas(name string) (*types.Transaction, error) {
+	return _Vm.Contract.StartSnapshotGas(&_Vm.TransactOpts, name)
+}
+
+// StartSnapshotGas is a paid mutator transaction binding the contract method 0x3cad9d7b.
+//
+// Solidity: function startSnapshotGas(string name) returns()
+func (_Vm *VmTransactorSession) StartSnapshotGas(name string) (*types.Transaction, error) {
+	return _Vm.Contract.StartSnapshotGas(&_Vm.TransactOpts, name)
+}
+
+// StartSnapshotGas0 is a paid mutator transaction binding the contract method 0x6cd0cc53.
+//
+// Solidity: function startSnapshotGas(string group, string name) returns()
+func (_Vm *VmTransactor) StartSnapshotGas0(opts *bind.TransactOpts, group string, name string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "startSnapshotGas0", group, name)
+}
+
+// StartSnapshotGas0 is a paid mutator transaction binding the contract method 0x6cd0cc53.
+//
+// Solidity: function startSnapshotGas(string group, string name) returns()
+func (_Vm *VmSession) StartSnapshotGas0(group string, name string) (*types.Transaction, error) {
+	return _Vm.Contract.StartSnapshotGas0(&_Vm.TransactOpts, group, name)
+}
+
+// StartSnapshotGas0 is a paid mutator transaction binding the contract method 0x6cd0cc53.
+//
+// Solidity: function startSnapshotGas(string group, string name) returns()
+func (_Vm *VmTransactorSession) StartSnapshotGas0(group string, name string) (*types.Transaction, error) {
+	return _Vm.Contract.StartSnapshotGas0(&_Vm.TransactOpts, group, name)
+}
+
+// StartStateDiffRecording is a paid mutator transaction binding the contract method 0xcf22e3c9.
+//
+// Solidity: function startStateDiffRecording() returns()
+func (_Vm *VmTransactor) StartStateDiffRecording(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "startStateDiffRecording")
+}
+
+// StartStateDiffRecording is a paid mutator transaction binding the contract method 0xcf22e3c9.
+//
+// Solidity: function startStateDiffRecording() returns()
+func (_Vm *VmSession) StartStateDiffRecording() (*types.Transaction, error) {
+	return _Vm.Contract.StartStateDiffRecording(&_Vm.TransactOpts)
+}
+
+// StartStateDiffRecording is a paid mutator transaction binding the contract method 0xcf22e3c9.
+//
+// Solidity: function startStateDiffRecording() returns()
+func (_Vm *VmTransactorSession) StartStateDiffRecording() (*types.Transaction, error) {
+	return _Vm.Contract.StartStateDiffRecording(&_Vm.TransactOpts)
+}
+
+// StopAndReturnDebugTraceRecording is a paid mutator transaction binding the contract method 0xced398a2.
+//
+// Solidity: function stopAndReturnDebugTraceRecording() returns((uint256[],bytes,uint8,uint64,bool,address)[] step)
+func (_Vm *VmTransactor) StopAndReturnDebugTraceRecording(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "stopAndReturnDebugTraceRecording")
+}
+
+// StopAndReturnDebugTraceRecording is a paid mutator transaction binding the contract method 0xced398a2.
+//
+// Solidity: function stopAndReturnDebugTraceRecording() returns((uint256[],bytes,uint8,uint64,bool,address)[] step)
+func (_Vm *VmSession) StopAndReturnDebugTraceRecording() (*types.Transaction, error) {
+	return _Vm.Contract.StopAndReturnDebugTraceRecording(&_Vm.TransactOpts)
+}
+
+// StopAndReturnDebugTraceRecording is a paid mutator transaction binding the contract method 0xced398a2.
+//
+// Solidity: function stopAndReturnDebugTraceRecording() returns((uint256[],bytes,uint8,uint64,bool,address)[] step)
+func (_Vm *VmTransactorSession) StopAndReturnDebugTraceRecording() (*types.Transaction, error) {
+	return _Vm.Contract.StopAndReturnDebugTraceRecording(&_Vm.TransactOpts)
+}
+
+// StopAndReturnStateDiff is a paid mutator transaction binding the contract method 0xaa5cf90e.
+//
+// Solidity: function stopAndReturnStateDiff() returns(((uint256,uint256),uint8,address,address,bool,uint256,uint256,bytes,uint256,bytes,bool,(address,bytes32,bool,bytes32,bytes32,bool)[],uint64)[] accountAccesses)
+func (_Vm *VmTransactor) StopAndReturnStateDiff(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "stopAndReturnStateDiff")
+}
+
+// StopAndReturnStateDiff is a paid mutator transaction binding the contract method 0xaa5cf90e.
+//
+// Solidity: function stopAndReturnStateDiff() returns(((uint256,uint256),uint8,address,address,bool,uint256,uint256,bytes,uint256,bytes,bool,(address,bytes32,bool,bytes32,bytes32,bool)[],uint64)[] accountAccesses)
+func (_Vm *VmSession) StopAndReturnStateDiff() (*types.Transaction, error) {
+	return _Vm.Contract.StopAndReturnStateDiff(&_Vm.TransactOpts)
+}
+
+// StopAndReturnStateDiff is a paid mutator transaction binding the contract method 0xaa5cf90e.
+//
+// Solidity: function stopAndReturnStateDiff() returns(((uint256,uint256),uint8,address,address,bool,uint256,uint256,bytes,uint256,bytes,bool,(address,bytes32,bool,bytes32,bytes32,bool)[],uint64)[] accountAccesses)
+func (_Vm *VmTransactorSession) StopAndReturnStateDiff() (*types.Transaction, error) {
+	return _Vm.Contract.StopAndReturnStateDiff(&_Vm.TransactOpts)
+}
+
+// StopBroadcast is a paid mutator transaction binding the contract method 0x76eadd36.
+//
+// Solidity: function stopBroadcast() returns()
+func (_Vm *VmTransactor) StopBroadcast(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "stopBroadcast")
+}
+
+// StopBroadcast is a paid mutator transaction binding the contract method 0x76eadd36.
+//
+// Solidity: function stopBroadcast() returns()
+func (_Vm *VmSession) StopBroadcast() (*types.Transaction, error) {
+	return _Vm.Contract.StopBroadcast(&_Vm.TransactOpts)
+}
+
+// StopBroadcast is a paid mutator transaction binding the contract method 0x76eadd36.
+//
+// Solidity: function stopBroadcast() returns()
+func (_Vm *VmTransactorSession) StopBroadcast() (*types.Transaction, error) {
+	return _Vm.Contract.StopBroadcast(&_Vm.TransactOpts)
+}
+
+// StopExpectSafeMemory is a paid mutator transaction binding the contract method 0x0956441b.
+//
+// Solidity: function stopExpectSafeMemory() returns()
+func (_Vm *VmTransactor) StopExpectSafeMemory(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "stopExpectSafeMemory")
+}
+
+// StopExpectSafeMemory is a paid mutator transaction binding the contract method 0x0956441b.
+//
+// Solidity: function stopExpectSafeMemory() returns()
+func (_Vm *VmSession) StopExpectSafeMemory() (*types.Transaction, error) {
+	return _Vm.Contract.StopExpectSafeMemory(&_Vm.TransactOpts)
+}
+
+// StopExpectSafeMemory is a paid mutator transaction binding the contract method 0x0956441b.
+//
+// Solidity: function stopExpectSafeMemory() returns()
+func (_Vm *VmTransactorSession) StopExpectSafeMemory() (*types.Transaction, error) {
+	return _Vm.Contract.StopExpectSafeMemory(&_Vm.TransactOpts)
+}
+
+// StopMappingRecording is a paid mutator transaction binding the contract method 0x0d4aae9b.
+//
+// Solidity: function stopMappingRecording() returns()
+func (_Vm *VmTransactor) StopMappingRecording(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "stopMappingRecording")
+}
+
+// StopMappingRecording is a paid mutator transaction binding the contract method 0x0d4aae9b.
+//
+// Solidity: function stopMappingRecording() returns()
+func (_Vm *VmSession) StopMappingRecording() (*types.Transaction, error) {
+	return _Vm.Contract.StopMappingRecording(&_Vm.TransactOpts)
+}
+
+// StopMappingRecording is a paid mutator transaction binding the contract method 0x0d4aae9b.
+//
+// Solidity: function stopMappingRecording() returns()
+func (_Vm *VmTransactorSession) StopMappingRecording() (*types.Transaction, error) {
+	return _Vm.Contract.StopMappingRecording(&_Vm.TransactOpts)
+}
+
+// StopPrank is a paid mutator transaction binding the contract method 0x90c5013b.
+//
+// Solidity: function stopPrank() returns()
+func (_Vm *VmTransactor) StopPrank(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "stopPrank")
+}
+
+// StopPrank is a paid mutator transaction binding the contract method 0x90c5013b.
+//
+// Solidity: function stopPrank() returns()
+func (_Vm *VmSession) StopPrank() (*types.Transaction, error) {
+	return _Vm.Contract.StopPrank(&_Vm.TransactOpts)
+}
+
+// StopPrank is a paid mutator transaction binding the contract method 0x90c5013b.
+//
+// Solidity: function stopPrank() returns()
+func (_Vm *VmTransactorSession) StopPrank() (*types.Transaction, error) {
+	return _Vm.Contract.StopPrank(&_Vm.TransactOpts)
+}
+
+// StopSnapshotGas is a paid mutator transaction binding the contract method 0x0c9db707.
+//
+// Solidity: function stopSnapshotGas(string group, string name) returns(uint256 gasUsed)
+func (_Vm *VmTransactor) StopSnapshotGas(opts *bind.TransactOpts, group string, name string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "stopSnapshotGas", group, name)
+}
+
+// StopSnapshotGas is a paid mutator transaction binding the contract method 0x0c9db707.
+//
+// Solidity: function stopSnapshotGas(string group, string name) returns(uint256 gasUsed)
+func (_Vm *VmSession) StopSnapshotGas(group string, name string) (*types.Transaction, error) {
+	return _Vm.Contract.StopSnapshotGas(&_Vm.TransactOpts, group, name)
+}
+
+// StopSnapshotGas is a paid mutator transaction binding the contract method 0x0c9db707.
+//
+// Solidity: function stopSnapshotGas(string group, string name) returns(uint256 gasUsed)
+func (_Vm *VmTransactorSession) StopSnapshotGas(group string, name string) (*types.Transaction, error) {
+	return _Vm.Contract.StopSnapshotGas(&_Vm.TransactOpts, group, name)
+}
+
+// StopSnapshotGas0 is a paid mutator transaction binding the contract method 0x773b2805.
+//
+// Solidity: function stopSnapshotGas(string name) returns(uint256 gasUsed)
+func (_Vm *VmTransactor) StopSnapshotGas0(opts *bind.TransactOpts, name string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "stopSnapshotGas0", name)
+}
+
+// StopSnapshotGas0 is a paid mutator transaction binding the contract method 0x773b2805.
+//
+// Solidity: function stopSnapshotGas(string name) returns(uint256 gasUsed)
+func (_Vm *VmSession) StopSnapshotGas0(name string) (*types.Transaction, error) {
+	return _Vm.Contract.StopSnapshotGas0(&_Vm.TransactOpts, name)
+}
+
+// StopSnapshotGas0 is a paid mutator transaction binding the contract method 0x773b2805.
+//
+// Solidity: function stopSnapshotGas(string name) returns(uint256 gasUsed)
+func (_Vm *VmTransactorSession) StopSnapshotGas0(name string) (*types.Transaction, error) {
+	return _Vm.Contract.StopSnapshotGas0(&_Vm.TransactOpts, name)
+}
+
+// StopSnapshotGas1 is a paid mutator transaction binding the contract method 0xf6402eda.
+//
+// Solidity: function stopSnapshotGas() returns(uint256 gasUsed)
+func (_Vm *VmTransactor) StopSnapshotGas1(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "stopSnapshotGas1")
+}
+
+// StopSnapshotGas1 is a paid mutator transaction binding the contract method 0xf6402eda.
+//
+// Solidity: function stopSnapshotGas() returns(uint256 gasUsed)
+func (_Vm *VmSession) StopSnapshotGas1() (*types.Transaction, error) {
+	return _Vm.Contract.StopSnapshotGas1(&_Vm.TransactOpts)
+}
+
+// StopSnapshotGas1 is a paid mutator transaction binding the contract method 0xf6402eda.
+//
+// Solidity: function stopSnapshotGas() returns(uint256 gasUsed)
+func (_Vm *VmTransactorSession) StopSnapshotGas1() (*types.Transaction, error) {
+	return _Vm.Contract.StopSnapshotGas1(&_Vm.TransactOpts)
+}
+
+// Store is a paid mutator transaction binding the contract method 0x70ca10bb.
+//
+// Solidity: function store(address target, bytes32 slot, bytes32 value) returns()
+func (_Vm *VmTransactor) Store(opts *bind.TransactOpts, target common.Address, slot [32]byte, value [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "store", target, slot, value)
+}
+
+// Store is a paid mutator transaction binding the contract method 0x70ca10bb.
+//
+// Solidity: function store(address target, bytes32 slot, bytes32 value) returns()
+func (_Vm *VmSession) Store(target common.Address, slot [32]byte, value [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.Store(&_Vm.TransactOpts, target, slot, value)
+}
+
+// Store is a paid mutator transaction binding the contract method 0x70ca10bb.
+//
+// Solidity: function store(address target, bytes32 slot, bytes32 value) returns()
+func (_Vm *VmTransactorSession) Store(target common.Address, slot [32]byte, value [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.Store(&_Vm.TransactOpts, target, slot, value)
+}
+
+// Transact is a paid mutator transaction binding the contract method 0x4d8abc4b.
+//
+// Solidity: function transact(uint256 forkId, bytes32 txHash) returns()
+func (_Vm *VmTransactor) Transact(opts *bind.TransactOpts, forkId *big.Int, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "transact", forkId, txHash)
+}
+
+// Transact is a paid mutator transaction binding the contract method 0x4d8abc4b.
+//
+// Solidity: function transact(uint256 forkId, bytes32 txHash) returns()
+func (_Vm *VmSession) Transact(forkId *big.Int, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.Transact(&_Vm.TransactOpts, forkId, txHash)
+}
+
+// Transact is a paid mutator transaction binding the contract method 0x4d8abc4b.
+//
+// Solidity: function transact(uint256 forkId, bytes32 txHash) returns()
+func (_Vm *VmTransactorSession) Transact(forkId *big.Int, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.Transact(&_Vm.TransactOpts, forkId, txHash)
+}
+
+// Transact0 is a paid mutator transaction binding the contract method 0xbe646da1.
+//
+// Solidity: function transact(bytes32 txHash) returns()
+func (_Vm *VmTransactor) Transact0(opts *bind.TransactOpts, txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "transact0", txHash)
+}
+
+// Transact0 is a paid mutator transaction binding the contract method 0xbe646da1.
+//
+// Solidity: function transact(bytes32 txHash) returns()
+func (_Vm *VmSession) Transact0(txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.Transact0(&_Vm.TransactOpts, txHash)
+}
+
+// Transact0 is a paid mutator transaction binding the contract method 0xbe646da1.
+//
+// Solidity: function transact(bytes32 txHash) returns()
+func (_Vm *VmTransactorSession) Transact0(txHash [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.Transact0(&_Vm.TransactOpts, txHash)
+}
+
+// TryFfi is a paid mutator transaction binding the contract method 0xf45c1ce7.
+//
+// Solidity: function tryFfi(string[] commandInput) returns((int32,bytes,bytes) result)
+func (_Vm *VmTransactor) TryFfi(opts *bind.TransactOpts, commandInput []string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "tryFfi", commandInput)
+}
+
+// TryFfi is a paid mutator transaction binding the contract method 0xf45c1ce7.
+//
+// Solidity: function tryFfi(string[] commandInput) returns((int32,bytes,bytes) result)
+func (_Vm *VmSession) TryFfi(commandInput []string) (*types.Transaction, error) {
+	return _Vm.Contract.TryFfi(&_Vm.TransactOpts, commandInput)
+}
+
+// TryFfi is a paid mutator transaction binding the contract method 0xf45c1ce7.
+//
+// Solidity: function tryFfi(string[] commandInput) returns((int32,bytes,bytes) result)
+func (_Vm *VmTransactorSession) TryFfi(commandInput []string) (*types.Transaction, error) {
+	return _Vm.Contract.TryFfi(&_Vm.TransactOpts, commandInput)
+}
+
+// TxGasPrice is a paid mutator transaction binding the contract method 0x48f50c0f.
+//
+// Solidity: function txGasPrice(uint256 newGasPrice) returns()
+func (_Vm *VmTransactor) TxGasPrice(opts *bind.TransactOpts, newGasPrice *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "txGasPrice", newGasPrice)
+}
+
+// TxGasPrice is a paid mutator transaction binding the contract method 0x48f50c0f.
+//
+// Solidity: function txGasPrice(uint256 newGasPrice) returns()
+func (_Vm *VmSession) TxGasPrice(newGasPrice *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.TxGasPrice(&_Vm.TransactOpts, newGasPrice)
+}
+
+// TxGasPrice is a paid mutator transaction binding the contract method 0x48f50c0f.
+//
+// Solidity: function txGasPrice(uint256 newGasPrice) returns()
+func (_Vm *VmTransactorSession) TxGasPrice(newGasPrice *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.TxGasPrice(&_Vm.TransactOpts, newGasPrice)
+}
+
+// WarmSlot is a paid mutator transaction binding the contract method 0xb23184cf.
+//
+// Solidity: function warmSlot(address target, bytes32 slot) returns()
+func (_Vm *VmTransactor) WarmSlot(opts *bind.TransactOpts, target common.Address, slot [32]byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "warmSlot", target, slot)
+}
+
+// WarmSlot is a paid mutator transaction binding the contract method 0xb23184cf.
+//
+// Solidity: function warmSlot(address target, bytes32 slot) returns()
+func (_Vm *VmSession) WarmSlot(target common.Address, slot [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.WarmSlot(&_Vm.TransactOpts, target, slot)
+}
+
+// WarmSlot is a paid mutator transaction binding the contract method 0xb23184cf.
+//
+// Solidity: function warmSlot(address target, bytes32 slot) returns()
+func (_Vm *VmTransactorSession) WarmSlot(target common.Address, slot [32]byte) (*types.Transaction, error) {
+	return _Vm.Contract.WarmSlot(&_Vm.TransactOpts, target, slot)
+}
+
+// Warp is a paid mutator transaction binding the contract method 0xe5d6bf02.
+//
+// Solidity: function warp(uint256 newTimestamp) returns()
+func (_Vm *VmTransactor) Warp(opts *bind.TransactOpts, newTimestamp *big.Int) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "warp", newTimestamp)
+}
+
+// Warp is a paid mutator transaction binding the contract method 0xe5d6bf02.
+//
+// Solidity: function warp(uint256 newTimestamp) returns()
+func (_Vm *VmSession) Warp(newTimestamp *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Warp(&_Vm.TransactOpts, newTimestamp)
+}
+
+// Warp is a paid mutator transaction binding the contract method 0xe5d6bf02.
+//
+// Solidity: function warp(uint256 newTimestamp) returns()
+func (_Vm *VmTransactorSession) Warp(newTimestamp *big.Int) (*types.Transaction, error) {
+	return _Vm.Contract.Warp(&_Vm.TransactOpts, newTimestamp)
+}
+
+// WriteFile is a paid mutator transaction binding the contract method 0x897e0a97.
+//
+// Solidity: function writeFile(string path, string data) returns()
+func (_Vm *VmTransactor) WriteFile(opts *bind.TransactOpts, path string, data string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "writeFile", path, data)
+}
+
+// WriteFile is a paid mutator transaction binding the contract method 0x897e0a97.
+//
+// Solidity: function writeFile(string path, string data) returns()
+func (_Vm *VmSession) WriteFile(path string, data string) (*types.Transaction, error) {
+	return _Vm.Contract.WriteFile(&_Vm.TransactOpts, path, data)
+}
+
+// WriteFile is a paid mutator transaction binding the contract method 0x897e0a97.
+//
+// Solidity: function writeFile(string path, string data) returns()
+func (_Vm *VmTransactorSession) WriteFile(path string, data string) (*types.Transaction, error) {
+	return _Vm.Contract.WriteFile(&_Vm.TransactOpts, path, data)
+}
+
+// WriteFileBinary is a paid mutator transaction binding the contract method 0x1f21fc80.
+//
+// Solidity: function writeFileBinary(string path, bytes data) returns()
+func (_Vm *VmTransactor) WriteFileBinary(opts *bind.TransactOpts, path string, data []byte) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "writeFileBinary", path, data)
+}
+
+// WriteFileBinary is a paid mutator transaction binding the contract method 0x1f21fc80.
+//
+// Solidity: function writeFileBinary(string path, bytes data) returns()
+func (_Vm *VmSession) WriteFileBinary(path string, data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.WriteFileBinary(&_Vm.TransactOpts, path, data)
+}
+
+// WriteFileBinary is a paid mutator transaction binding the contract method 0x1f21fc80.
+//
+// Solidity: function writeFileBinary(string path, bytes data) returns()
+func (_Vm *VmTransactorSession) WriteFileBinary(path string, data []byte) (*types.Transaction, error) {
+	return _Vm.Contract.WriteFileBinary(&_Vm.TransactOpts, path, data)
+}
+
+// WriteJson is a paid mutator transaction binding the contract method 0x35d6ad46.
+//
+// Solidity: function writeJson(string json, string path, string valueKey) returns()
+func (_Vm *VmTransactor) WriteJson(opts *bind.TransactOpts, json string, path string, valueKey string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "writeJson", json, path, valueKey)
+}
+
+// WriteJson is a paid mutator transaction binding the contract method 0x35d6ad46.
+//
+// Solidity: function writeJson(string json, string path, string valueKey) returns()
+func (_Vm *VmSession) WriteJson(json string, path string, valueKey string) (*types.Transaction, error) {
+	return _Vm.Contract.WriteJson(&_Vm.TransactOpts, json, path, valueKey)
+}
+
+// WriteJson is a paid mutator transaction binding the contract method 0x35d6ad46.
+//
+// Solidity: function writeJson(string json, string path, string valueKey) returns()
+func (_Vm *VmTransactorSession) WriteJson(json string, path string, valueKey string) (*types.Transaction, error) {
+	return _Vm.Contract.WriteJson(&_Vm.TransactOpts, json, path, valueKey)
+}
+
+// WriteJson0 is a paid mutator transaction binding the contract method 0xe23cd19f.
+//
+// Solidity: function writeJson(string json, string path) returns()
+func (_Vm *VmTransactor) WriteJson0(opts *bind.TransactOpts, json string, path string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "writeJson0", json, path)
+}
+
+// WriteJson0 is a paid mutator transaction binding the contract method 0xe23cd19f.
+//
+// Solidity: function writeJson(string json, string path) returns()
+func (_Vm *VmSession) WriteJson0(json string, path string) (*types.Transaction, error) {
+	return _Vm.Contract.WriteJson0(&_Vm.TransactOpts, json, path)
+}
+
+// WriteJson0 is a paid mutator transaction binding the contract method 0xe23cd19f.
+//
+// Solidity: function writeJson(string json, string path) returns()
+func (_Vm *VmTransactorSession) WriteJson0(json string, path string) (*types.Transaction, error) {
+	return _Vm.Contract.WriteJson0(&_Vm.TransactOpts, json, path)
+}
+
+// WriteLine is a paid mutator transaction binding the contract method 0x619d897f.
+//
+// Solidity: function writeLine(string path, string data) returns()
+func (_Vm *VmTransactor) WriteLine(opts *bind.TransactOpts, path string, data string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "writeLine", path, data)
+}
+
+// WriteLine is a paid mutator transaction binding the contract method 0x619d897f.
+//
+// Solidity: function writeLine(string path, string data) returns()
+func (_Vm *VmSession) WriteLine(path string, data string) (*types.Transaction, error) {
+	return _Vm.Contract.WriteLine(&_Vm.TransactOpts, path, data)
+}
+
+// WriteLine is a paid mutator transaction binding the contract method 0x619d897f.
+//
+// Solidity: function writeLine(string path, string data) returns()
+func (_Vm *VmTransactorSession) WriteLine(path string, data string) (*types.Transaction, error) {
+	return _Vm.Contract.WriteLine(&_Vm.TransactOpts, path, data)
+}
+
+// WriteToml is a paid mutator transaction binding the contract method 0x51ac6a33.
+//
+// Solidity: function writeToml(string json, string path, string valueKey) returns()
+func (_Vm *VmTransactor) WriteToml(opts *bind.TransactOpts, json string, path string, valueKey string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "writeToml", json, path, valueKey)
+}
+
+// WriteToml is a paid mutator transaction binding the contract method 0x51ac6a33.
+//
+// Solidity: function writeToml(string json, string path, string valueKey) returns()
+func (_Vm *VmSession) WriteToml(json string, path string, valueKey string) (*types.Transaction, error) {
+	return _Vm.Contract.WriteToml(&_Vm.TransactOpts, json, path, valueKey)
+}
+
+// WriteToml is a paid mutator transaction binding the contract method 0x51ac6a33.
+//
+// Solidity: function writeToml(string json, string path, string valueKey) returns()
+func (_Vm *VmTransactorSession) WriteToml(json string, path string, valueKey string) (*types.Transaction, error) {
+	return _Vm.Contract.WriteToml(&_Vm.TransactOpts, json, path, valueKey)
+}
+
+// WriteToml0 is a paid mutator transaction binding the contract method 0xc0865ba7.
+//
+// Solidity: function writeToml(string json, string path) returns()
+func (_Vm *VmTransactor) WriteToml0(opts *bind.TransactOpts, json string, path string) (*types.Transaction, error) {
+	return _Vm.contract.Transact(opts, "writeToml0", json, path)
+}
+
+// WriteToml0 is a paid mutator transaction binding the contract method 0xc0865ba7.
+//
+// Solidity: function writeToml(string json, string path) returns()
+func (_Vm *VmSession) WriteToml0(json string, path string) (*types.Transaction, error) {
+	return _Vm.Contract.WriteToml0(&_Vm.TransactOpts, json, path)
+}
+
+// WriteToml0 is a paid mutator transaction binding the contract method 0xc0865ba7.
+//
+// Solidity: function writeToml(string json, string path) returns()
+func (_Vm *VmTransactorSession) WriteToml0(json string, path string) (*types.Transaction, error) {
+	return _Vm.Contract.WriteToml0(&_Vm.TransactOpts, json, path)
+}
+
+// VmSafeMetaData contains all meta data concerning the VmSafe contract.
+var VmSafeMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"accesses\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"readSlots\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"writeSlots\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"addr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"keyAddr\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertFalse\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"}],\"name\":\"assertFalse\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"}],\"name\":\"assertTrue\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertTrue\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"}],\"name\":\"assume\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"assumeNoRevert\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"reverter\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"partialMatch\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"internalType\":\"structVmSafe.PotentialRevert[]\",\"name\":\"potentialReverts\",\"type\":\"tuple[]\"}],\"name\":\"assumeNoRevert\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"reverter\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"partialMatch\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"internalType\":\"structVmSafe.PotentialRevert\",\"name\":\"potentialRevert\",\"type\":\"tuple\"}],\"name\":\"assumeNoRevert\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"internalType\":\"structVmSafe.SignedDelegation\",\"name\":\"signedDelegation\",\"type\":\"tuple\"}],\"name\":\"attachDelegation\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"char\",\"type\":\"string\"}],\"name\":\"breakpoint\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"char\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"breakpoint\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"broadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"broadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"broadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"broadcastRawTransaction\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"closeFile\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"initCodeHash\",\"type\":\"bytes32\"}],\"name\":\"computeCreate2Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"initCodeHash\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"deployer\",\"type\":\"address\"}],\"name\":\"computeCreate2Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"deployer\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"computeCreateAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"subject\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"search\",\"type\":\"string\"}],\"name\":\"contains\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"from\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"to\",\"type\":\"string\"}],\"name\":\"copyFile\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"copied\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"copyStorage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"recursive\",\"type\":\"bool\"}],\"name\":\"createDir\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"walletLabel\",\"type\":\"string\"}],\"name\":\"createWallet\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"createWallet\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"walletLabel\",\"type\":\"string\"}],\"name\":\"createWallet\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"artifactPath\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"constructorArgs\",\"type\":\"bytes\"}],\"name\":\"deployCode\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"deployedAddress\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"artifactPath\",\"type\":\"string\"}],\"name\":\"deployCode\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"deployedAddress\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"derivationPath\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"internalType\":\"string\",\"name\":\"language\",\"type\":\"string\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"internalType\":\"string\",\"name\":\"language\",\"type\":\"string\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"derivationPath\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"ensNamehash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envAddress\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"value\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envBool\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"value\",\"type\":\"bool[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envBytes\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"value\",\"type\":\"bytes[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envBytes32\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"value\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envExists\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envInt\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"value\",\"type\":\"int256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"bytes32[]\",\"name\":\"defaultValue\",\"type\":\"bytes32[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"value\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"int256[]\",\"name\":\"defaultValue\",\"type\":\"int256[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"value\",\"type\":\"int256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"defaultValue\",\"type\":\"bool\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"defaultValue\",\"type\":\"address\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"defaultValue\",\"type\":\"uint256\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"bytes[]\",\"name\":\"defaultValue\",\"type\":\"bytes[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"value\",\"type\":\"bytes[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"defaultValue\",\"type\":\"uint256[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"value\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"string[]\",\"name\":\"defaultValue\",\"type\":\"string[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"value\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"defaultValue\",\"type\":\"bytes\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"defaultValue\",\"type\":\"bytes32\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"int256\",\"name\":\"defaultValue\",\"type\":\"int256\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"address[]\",\"name\":\"defaultValue\",\"type\":\"address[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"value\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"defaultValue\",\"type\":\"string\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"bool[]\",\"name\":\"defaultValue\",\"type\":\"bool[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"value\",\"type\":\"bool[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envString\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"value\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envUint\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"value\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"fromBlock\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBlock\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32[]\",\"name\":\"topics\",\"type\":\"bytes32[]\"}],\"name\":\"eth_getLogs\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"},{\"internalType\":\"bytes32[]\",\"name\":\"topics\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"transactionHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"transactionIndex\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"logIndex\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"removed\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.EthGetLogs[]\",\"name\":\"logs\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"exists\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"commandInput\",\"type\":\"string[]\"}],\"name\":\"ffi\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"result\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"version\",\"type\":\"string\"}],\"name\":\"foundryVersionAtLeast\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"version\",\"type\":\"string\"}],\"name\":\"foundryVersionCmp\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"fsMetadata\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"readOnly\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"modified\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"accessed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"created\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.FsMetadata\",\"name\":\"metadata\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"code\",\"type\":\"bytes\"}],\"name\":\"getArtifactPathByCode\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"deployedCode\",\"type\":\"bytes\"}],\"name\":\"getArtifactPathByDeployedCode\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlobBaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"blobBaseFee\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"height\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlockTimestamp\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"contractName\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"chainId\",\"type\":\"uint64\"},{\"internalType\":\"enumVmSafe.BroadcastTxType\",\"name\":\"txType\",\"type\":\"uint8\"}],\"name\":\"getBroadcast\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"},{\"internalType\":\"enumVmSafe.BroadcastTxType\",\"name\":\"txType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"contractAddress\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.BroadcastTxSummary\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"contractName\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"chainId\",\"type\":\"uint64\"}],\"name\":\"getBroadcasts\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"},{\"internalType\":\"enumVmSafe.BroadcastTxType\",\"name\":\"txType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"contractAddress\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.BroadcastTxSummary[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"contractName\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"chainId\",\"type\":\"uint64\"},{\"internalType\":\"enumVmSafe.BroadcastTxType\",\"name\":\"txType\",\"type\":\"uint8\"}],\"name\":\"getBroadcasts\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"},{\"internalType\":\"enumVmSafe.BroadcastTxType\",\"name\":\"txType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"contractAddress\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.BroadcastTxSummary[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"artifactPath\",\"type\":\"string\"}],\"name\":\"getCode\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"creationBytecode\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"artifactPath\",\"type\":\"string\"}],\"name\":\"getDeployedCode\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"runtimeBytecode\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"contractName\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"chainId\",\"type\":\"uint64\"}],\"name\":\"getDeployment\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"deployedAddress\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"contractName\",\"type\":\"string\"}],\"name\":\"getDeployment\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"deployedAddress\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"contractName\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"chainId\",\"type\":\"uint64\"}],\"name\":\"getDeployments\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"deployedAddresses\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getFoundryVersion\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"version\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getLabel\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"currentLabel\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"elementSlot\",\"type\":\"bytes32\"}],\"name\":\"getMappingKeyAndParentOf\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"found\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"parent\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"mappingSlot\",\"type\":\"bytes32\"}],\"name\":\"getMappingLength\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"mappingSlot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"idx\",\"type\":\"uint256\"}],\"name\":\"getMappingSlotAt\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getNonce\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"name\":\"getNonce\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRecordedLogs\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32[]\",\"name\":\"topics\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"}],\"internalType\":\"structVmSafe.Log[]\",\"name\":\"logs\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getStateDiff\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"diff\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getStateDiffJson\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"diff\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getWallets\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"wallets\",\"type\":\"address[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"indexOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumVmSafe.ForgeContext\",\"name\":\"context\",\"type\":\"uint8\"}],\"name\":\"isContext\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"isDir\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"isFile\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"keyExists\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"keyExistsJson\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"keyExistsToml\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"newLabel\",\"type\":\"string\"}],\"name\":\"label\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastCallGas\",\"outputs\":[{\"components\":[{\"internalType\":\"uint64\",\"name\":\"gasLimit\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"gasTotalUsed\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"gasMemoryUsed\",\"type\":\"uint64\"},{\"internalType\":\"int64\",\"name\":\"gasRefunded\",\"type\":\"int64\"},{\"internalType\":\"uint64\",\"name\":\"gasRemaining\",\"type\":\"uint64\"}],\"internalType\":\"structVmSafe.Gas\",\"name\":\"gas\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"}],\"name\":\"load\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"data\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"parsedValue\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"parsedValue\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"parsedValue\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"parsedValue\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"parsedValue\",\"type\":\"int256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"name\":\"parseJson\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJson\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonAddressArray\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBoolArray\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"\",\"type\":\"bool[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytes32Array\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytesArray\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"\",\"type\":\"bytes[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonIntArray\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"\",\"type\":\"int256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonKeys\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"keys\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonStringArray\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"}],\"name\":\"parseJsonType\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"}],\"name\":\"parseJsonType\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"}],\"name\":\"parseJsonTypeArray\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonUintArray\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseToml\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"}],\"name\":\"parseToml\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlAddressArray\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBoolArray\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"\",\"type\":\"bool[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytes32Array\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytesArray\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"\",\"type\":\"bytes[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlIntArray\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"\",\"type\":\"int256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlKeys\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"keys\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlStringArray\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"}],\"name\":\"parseTomlType\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"}],\"name\":\"parseTomlType\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"}],\"name\":\"parseTomlTypeArray\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlUintArray\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"parsedValue\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseGasMetering\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseTracing\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"projectRoot\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"prompt\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptSecret\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptSecretUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"publicKeyP256\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"len\",\"type\":\"uint256\"}],\"name\":\"randomBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomBytes4\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomBytes8\",\"outputs\":[{\"internalType\":\"bytes8\",\"name\":\"\",\"type\":\"bytes8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"bits\",\"type\":\"uint256\"}],\"name\":\"randomInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"bits\",\"type\":\"uint256\"}],\"name\":\"randomUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"min\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"max\",\"type\":\"uint256\"}],\"name\":\"randomUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"maxDepth\",\"type\":\"uint64\"}],\"name\":\"readDir\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"errorMessage\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.DirEntry[]\",\"name\":\"entries\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"maxDepth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"followLinks\",\"type\":\"bool\"}],\"name\":\"readDir\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"errorMessage\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.DirEntry[]\",\"name\":\"entries\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readDir\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"errorMessage\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.DirEntry[]\",\"name\":\"entries\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readFile\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readFileBinary\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readLine\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"line\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"linkPath\",\"type\":\"string\"}],\"name\":\"readLink\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"targetPath\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"record\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"recordLogs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"rememberKey\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"keyAddr\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"derivationPath\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"count\",\"type\":\"uint32\"}],\"name\":\"rememberKeys\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"keyAddrs\",\"type\":\"address[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"derivationPath\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"language\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"count\",\"type\":\"uint32\"}],\"name\":\"rememberKeys\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"keyAddrs\",\"type\":\"address[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"recursive\",\"type\":\"bool\"}],\"name\":\"removeDir\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"removeFile\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"from\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"to\",\"type\":\"string\"}],\"name\":\"replace\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resetGasMetering\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resumeGasMetering\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resumeTracing\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"method\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"params\",\"type\":\"string\"}],\"name\":\"rpc\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"method\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"params\",\"type\":\"string\"}],\"name\":\"rpc\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"rpcAlias\",\"type\":\"string\"}],\"name\":\"rpcUrl\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rpcUrlStructs\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"url\",\"type\":\"string\"}],\"internalType\":\"structVmSafe.Rpc[]\",\"name\":\"urls\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rpcUrls\",\"outputs\":[{\"internalType\":\"string[2][]\",\"name\":\"urls\",\"type\":\"string[2][]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"address[]\",\"name\":\"values\",\"type\":\"address[]\"}],\"name\":\"serializeAddress\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"name\":\"serializeAddress\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bool[]\",\"name\":\"values\",\"type\":\"bool[]\"}],\"name\":\"serializeBool\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"serializeBool\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes[]\",\"name\":\"values\",\"type\":\"bytes[]\"}],\"name\":\"serializeBytes\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"serializeBytes\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes32[]\",\"name\":\"values\",\"type\":\"bytes32[]\"}],\"name\":\"serializeBytes32\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"name\":\"serializeBytes32\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"name\":\"serializeInt\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"int256[]\",\"name\":\"values\",\"type\":\"int256[]\"}],\"name\":\"serializeInt\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"name\":\"serializeJson\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"serializeJsonType\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"typeDescription\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"serializeJsonType\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"string[]\",\"name\":\"values\",\"type\":\"string[]\"}],\"name\":\"serializeString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"name\":\"serializeString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"serializeUint\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"values\",\"type\":\"uint256[]\"}],\"name\":\"serializeUint\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"serializeUintToHex\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"setArbitraryStorage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"name\":\"setEnv\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"signAndAttachDelegation\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"internalType\":\"structVmSafe.SignedDelegation\",\"name\":\"signedDelegation\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"signCompact\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"vs\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"signCompact\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"vs\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"signCompact\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"vs\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"signCompact\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"vs\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"signDelegation\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"internalType\":\"structVmSafe.SignedDelegation\",\"name\":\"signedDelegation\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"signP256\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"duration\",\"type\":\"uint256\"}],\"name\":\"sleep\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delimiter\",\"type\":\"string\"}],\"name\":\"split\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"outputs\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"startBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"startBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startDebugTraceRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startMappingRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startStateDiffRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopAndReturnDebugTraceRecording\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256[]\",\"name\":\"stack\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"memoryInput\",\"type\":\"bytes\"},{\"internalType\":\"uint8\",\"name\":\"opcode\",\"type\":\"uint8\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isOutOfGas\",\"type\":\"bool\"},{\"internalType\":\"address\",\"name\":\"contractAddr\",\"type\":\"address\"}],\"internalType\":\"structVmSafe.DebugStep[]\",\"name\":\"step\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopAndReturnStateDiff\",\"outputs\":[{\"components\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.ChainInfo\",\"name\":\"chainInfo\",\"type\":\"tuple\"},{\"internalType\":\"enumVmSafe.AccountAccessKind\",\"name\":\"kind\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"accessor\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"initialized\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"oldBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"newBalance\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"deployedCode\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bool\",\"name\":\"reverted\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"},{\"internalType\":\"bool\",\"name\":\"isWrite\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"previousValue\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newValue\",\"type\":\"bytes32\"},{\"internalType\":\"bool\",\"name\":\"reverted\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.StorageAccess[]\",\"name\":\"storageAccesses\",\"type\":\"tuple[]\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"}],\"internalType\":\"structVmSafe.AccountAccess[]\",\"name\":\"accountAccesses\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopMappingRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"toBase64\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"toBase64\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"toBase64URL\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"toBase64URL\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"name\":\"toLowercase\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"name\":\"toUppercase\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"name\":\"trim\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"commandInput\",\"type\":\"string[]\"}],\"name\":\"tryFfi\",\"outputs\":[{\"components\":[{\"internalType\":\"int32\",\"name\":\"exitCode\",\"type\":\"int32\"},{\"internalType\":\"bytes\",\"name\":\"stdout\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"stderr\",\"type\":\"bytes\"}],\"internalType\":\"structVmSafe.FfiResult\",\"name\":\"result\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unixTime\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"milliseconds\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"writeFile\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"writeFileBinary\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"}],\"name\":\"writeJson\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"writeJson\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"writeLine\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"}],\"name\":\"writeToml\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"writeToml\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
+}
+
+// VmSafeABI is the input ABI used to generate the binding from.
+// Deprecated: Use VmSafeMetaData.ABI instead.
+var VmSafeABI = VmSafeMetaData.ABI
+
+// VmSafe is an auto generated Go binding around an Ethereum contract.
+type VmSafe struct {
+	VmSafeCaller     // Read-only binding to the contract
+	VmSafeTransactor // Write-only binding to the contract
+	VmSafeFilterer   // Log filterer for contract events
+}
+
+// VmSafeCaller is an auto generated read-only Go binding around an Ethereum contract.
+type VmSafeCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// VmSafeTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type VmSafeTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// VmSafeFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type VmSafeFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// VmSafeSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type VmSafeSession struct {
+	Contract     *VmSafe           // 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
+}
+
+// VmSafeCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type VmSafeCallerSession struct {
+	Contract *VmSafeCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts // Call options to use throughout this session
+}
+
+// VmSafeTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type VmSafeTransactorSession struct {
+	Contract     *VmSafeTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// VmSafeRaw is an auto generated low-level Go binding around an Ethereum contract.
+type VmSafeRaw struct {
+	Contract *VmSafe // Generic contract binding to access the raw methods on
+}
+
+// VmSafeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type VmSafeCallerRaw struct {
+	Contract *VmSafeCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// VmSafeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type VmSafeTransactorRaw struct {
+	Contract *VmSafeTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewVmSafe creates a new instance of VmSafe, bound to a specific deployed contract.
+func NewVmSafe(address common.Address, backend bind.ContractBackend) (*VmSafe, error) {
+	contract, err := bindVmSafe(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &VmSafe{VmSafeCaller: VmSafeCaller{contract: contract}, VmSafeTransactor: VmSafeTransactor{contract: contract}, VmSafeFilterer: VmSafeFilterer{contract: contract}}, nil
+}
+
+// NewVmSafeCaller creates a new read-only instance of VmSafe, bound to a specific deployed contract.
+func NewVmSafeCaller(address common.Address, caller bind.ContractCaller) (*VmSafeCaller, error) {
+	contract, err := bindVmSafe(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &VmSafeCaller{contract: contract}, nil
+}
+
+// NewVmSafeTransactor creates a new write-only instance of VmSafe, bound to a specific deployed contract.
+func NewVmSafeTransactor(address common.Address, transactor bind.ContractTransactor) (*VmSafeTransactor, error) {
+	contract, err := bindVmSafe(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &VmSafeTransactor{contract: contract}, nil
+}
+
+// NewVmSafeFilterer creates a new log filterer instance of VmSafe, bound to a specific deployed contract.
+func NewVmSafeFilterer(address common.Address, filterer bind.ContractFilterer) (*VmSafeFilterer, error) {
+	contract, err := bindVmSafe(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &VmSafeFilterer{contract: contract}, nil
+}
+
+// bindVmSafe binds a generic wrapper to an already deployed contract.
+func bindVmSafe(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := VmSafeMetaData.GetAbi()
+	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 (_VmSafe *VmSafeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _VmSafe.Contract.VmSafeCaller.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 (_VmSafe *VmSafeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.Contract.VmSafeTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_VmSafe *VmSafeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _VmSafe.Contract.VmSafeTransactor.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 (_VmSafe *VmSafeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _VmSafe.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 (_VmSafe *VmSafeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_VmSafe *VmSafeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _VmSafe.Contract.contract.Transact(opts, method, params...)
+}
+
+// Addr is a free data retrieval call binding the contract method 0xffa18649.
+//
+// Solidity: function addr(uint256 privateKey) pure returns(address keyAddr)
+func (_VmSafe *VmSafeCaller) Addr(opts *bind.CallOpts, privateKey *big.Int) (common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "addr", privateKey)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// Addr is a free data retrieval call binding the contract method 0xffa18649.
+//
+// Solidity: function addr(uint256 privateKey) pure returns(address keyAddr)
+func (_VmSafe *VmSafeSession) Addr(privateKey *big.Int) (common.Address, error) {
+	return _VmSafe.Contract.Addr(&_VmSafe.CallOpts, privateKey)
+}
+
+// Addr is a free data retrieval call binding the contract method 0xffa18649.
+//
+// Solidity: function addr(uint256 privateKey) pure returns(address keyAddr)
+func (_VmSafe *VmSafeCallerSession) Addr(privateKey *big.Int) (common.Address, error) {
+	return _VmSafe.Contract.Addr(&_VmSafe.CallOpts, privateKey)
+}
+
+// AssertApproxEqAbs is a free data retrieval call binding the contract method 0x16d207c6.
+//
+// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqAbs(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbs", left, right, maxDelta)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbs is a free data retrieval call binding the contract method 0x16d207c6.
+//
+// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqAbs(left *big.Int, right *big.Int, maxDelta *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqAbs(&_VmSafe.CallOpts, left, right, maxDelta)
+}
+
+// AssertApproxEqAbs is a free data retrieval call binding the contract method 0x16d207c6.
+//
+// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbs(left *big.Int, right *big.Int, maxDelta *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqAbs(&_VmSafe.CallOpts, left, right, maxDelta)
+}
+
+// AssertApproxEqAbs0 is a free data retrieval call binding the contract method 0x240f839d.
+//
+// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqAbs0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbs0", left, right, maxDelta)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbs0 is a free data retrieval call binding the contract method 0x240f839d.
+//
+// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqAbs0(left *big.Int, right *big.Int, maxDelta *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqAbs0(&_VmSafe.CallOpts, left, right, maxDelta)
+}
+
+// AssertApproxEqAbs0 is a free data retrieval call binding the contract method 0x240f839d.
+//
+// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbs0(left *big.Int, right *big.Int, maxDelta *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqAbs0(&_VmSafe.CallOpts, left, right, maxDelta)
+}
+
+// AssertApproxEqAbs1 is a free data retrieval call binding the contract method 0x8289e621.
+//
+// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqAbs1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbs1", left, right, maxDelta, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbs1 is a free data retrieval call binding the contract method 0x8289e621.
+//
+// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqAbs1(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqAbs1(&_VmSafe.CallOpts, left, right, maxDelta, error)
+}
+
+// AssertApproxEqAbs1 is a free data retrieval call binding the contract method 0x8289e621.
+//
+// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbs1(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqAbs1(&_VmSafe.CallOpts, left, right, maxDelta, error)
+}
+
+// AssertApproxEqAbs2 is a free data retrieval call binding the contract method 0xf710b062.
+//
+// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqAbs2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbs2", left, right, maxDelta, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbs2 is a free data retrieval call binding the contract method 0xf710b062.
+//
+// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqAbs2(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqAbs2(&_VmSafe.CallOpts, left, right, maxDelta, error)
+}
+
+// AssertApproxEqAbs2 is a free data retrieval call binding the contract method 0xf710b062.
+//
+// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbs2(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqAbs2(&_VmSafe.CallOpts, left, right, maxDelta, error)
+}
+
+// AssertApproxEqAbsDecimal is a free data retrieval call binding the contract method 0x045c55ce.
+//
+// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqAbsDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbsDecimal", left, right, maxDelta, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbsDecimal is a free data retrieval call binding the contract method 0x045c55ce.
+//
+// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqAbsDecimal(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqAbsDecimal(&_VmSafe.CallOpts, left, right, maxDelta, decimals)
+}
+
+// AssertApproxEqAbsDecimal is a free data retrieval call binding the contract method 0x045c55ce.
+//
+// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbsDecimal(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqAbsDecimal(&_VmSafe.CallOpts, left, right, maxDelta, decimals)
+}
+
+// AssertApproxEqAbsDecimal0 is a free data retrieval call binding the contract method 0x3d5bc8bc.
+//
+// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqAbsDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbsDecimal0", left, right, maxDelta, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbsDecimal0 is a free data retrieval call binding the contract method 0x3d5bc8bc.
+//
+// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqAbsDecimal0(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqAbsDecimal0(&_VmSafe.CallOpts, left, right, maxDelta, decimals)
+}
+
+// AssertApproxEqAbsDecimal0 is a free data retrieval call binding the contract method 0x3d5bc8bc.
+//
+// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbsDecimal0(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqAbsDecimal0(&_VmSafe.CallOpts, left, right, maxDelta, decimals)
+}
+
+// AssertApproxEqAbsDecimal1 is a free data retrieval call binding the contract method 0x60429eb2.
+//
+// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqAbsDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbsDecimal1", left, right, maxDelta, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbsDecimal1 is a free data retrieval call binding the contract method 0x60429eb2.
+//
+// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqAbsDecimal1(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqAbsDecimal1(&_VmSafe.CallOpts, left, right, maxDelta, decimals, error)
+}
+
+// AssertApproxEqAbsDecimal1 is a free data retrieval call binding the contract method 0x60429eb2.
+//
+// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbsDecimal1(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqAbsDecimal1(&_VmSafe.CallOpts, left, right, maxDelta, decimals, error)
+}
+
+// AssertApproxEqAbsDecimal2 is a free data retrieval call binding the contract method 0x6a5066d4.
+//
+// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqAbsDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbsDecimal2", left, right, maxDelta, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqAbsDecimal2 is a free data retrieval call binding the contract method 0x6a5066d4.
+//
+// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqAbsDecimal2(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqAbsDecimal2(&_VmSafe.CallOpts, left, right, maxDelta, decimals, error)
+}
+
+// AssertApproxEqAbsDecimal2 is a free data retrieval call binding the contract method 0x6a5066d4.
+//
+// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbsDecimal2(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqAbsDecimal2(&_VmSafe.CallOpts, left, right, maxDelta, decimals, error)
+}
+
+// AssertApproxEqRel is a free data retrieval call binding the contract method 0x1ecb7d33.
+//
+// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqRel(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRel", left, right, maxPercentDelta, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRel is a free data retrieval call binding the contract method 0x1ecb7d33.
+//
+// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqRel(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqRel(&_VmSafe.CallOpts, left, right, maxPercentDelta, error)
+}
+
+// AssertApproxEqRel is a free data retrieval call binding the contract method 0x1ecb7d33.
+//
+// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqRel(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqRel(&_VmSafe.CallOpts, left, right, maxPercentDelta, error)
+}
+
+// AssertApproxEqRel0 is a free data retrieval call binding the contract method 0x8cf25ef4.
+//
+// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqRel0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRel0", left, right, maxPercentDelta)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRel0 is a free data retrieval call binding the contract method 0x8cf25ef4.
+//
+// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqRel0(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqRel0(&_VmSafe.CallOpts, left, right, maxPercentDelta)
+}
+
+// AssertApproxEqRel0 is a free data retrieval call binding the contract method 0x8cf25ef4.
+//
+// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqRel0(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqRel0(&_VmSafe.CallOpts, left, right, maxPercentDelta)
+}
+
+// AssertApproxEqRel1 is a free data retrieval call binding the contract method 0xef277d72.
+//
+// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqRel1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRel1", left, right, maxPercentDelta, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRel1 is a free data retrieval call binding the contract method 0xef277d72.
+//
+// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqRel1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqRel1(&_VmSafe.CallOpts, left, right, maxPercentDelta, error)
+}
+
+// AssertApproxEqRel1 is a free data retrieval call binding the contract method 0xef277d72.
+//
+// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqRel1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqRel1(&_VmSafe.CallOpts, left, right, maxPercentDelta, error)
+}
+
+// AssertApproxEqRel2 is a free data retrieval call binding the contract method 0xfea2d14f.
+//
+// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqRel2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRel2", left, right, maxPercentDelta)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRel2 is a free data retrieval call binding the contract method 0xfea2d14f.
+//
+// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqRel2(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqRel2(&_VmSafe.CallOpts, left, right, maxPercentDelta)
+}
+
+// AssertApproxEqRel2 is a free data retrieval call binding the contract method 0xfea2d14f.
+//
+// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqRel2(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqRel2(&_VmSafe.CallOpts, left, right, maxPercentDelta)
+}
+
+// AssertApproxEqRelDecimal is a free data retrieval call binding the contract method 0x21ed2977.
+//
+// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqRelDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRelDecimal", left, right, maxPercentDelta, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRelDecimal is a free data retrieval call binding the contract method 0x21ed2977.
+//
+// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqRelDecimal(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqRelDecimal(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals)
+}
+
+// AssertApproxEqRelDecimal is a free data retrieval call binding the contract method 0x21ed2977.
+//
+// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqRelDecimal(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqRelDecimal(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals)
+}
+
+// AssertApproxEqRelDecimal0 is a free data retrieval call binding the contract method 0x82d6c8fd.
+//
+// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqRelDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRelDecimal0", left, right, maxPercentDelta, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRelDecimal0 is a free data retrieval call binding the contract method 0x82d6c8fd.
+//
+// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqRelDecimal0(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqRelDecimal0(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals, error)
+}
+
+// AssertApproxEqRelDecimal0 is a free data retrieval call binding the contract method 0x82d6c8fd.
+//
+// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqRelDecimal0(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqRelDecimal0(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals, error)
+}
+
+// AssertApproxEqRelDecimal1 is a free data retrieval call binding the contract method 0xabbf21cc.
+//
+// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqRelDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRelDecimal1", left, right, maxPercentDelta, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRelDecimal1 is a free data retrieval call binding the contract method 0xabbf21cc.
+//
+// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqRelDecimal1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqRelDecimal1(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals)
+}
+
+// AssertApproxEqRelDecimal1 is a free data retrieval call binding the contract method 0xabbf21cc.
+//
+// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqRelDecimal1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertApproxEqRelDecimal1(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals)
+}
+
+// AssertApproxEqRelDecimal2 is a free data retrieval call binding the contract method 0xfccc11c4.
+//
+// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertApproxEqRelDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRelDecimal2", left, right, maxPercentDelta, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertApproxEqRelDecimal2 is a free data retrieval call binding the contract method 0xfccc11c4.
+//
+// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertApproxEqRelDecimal2(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqRelDecimal2(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals, error)
+}
+
+// AssertApproxEqRelDecimal2 is a free data retrieval call binding the contract method 0xfccc11c4.
+//
+// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertApproxEqRelDecimal2(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertApproxEqRelDecimal2(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals, error)
+}
+
+// AssertEq is a free data retrieval call binding the contract method 0x0cc9ee84.
+//
+// Solidity: function assertEq(bytes32[] left, bytes32[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq(opts *bind.CallOpts, left [][32]byte, right [][32]byte) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq is a free data retrieval call binding the contract method 0x0cc9ee84.
+//
+// Solidity: function assertEq(bytes32[] left, bytes32[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq(left [][32]byte, right [][32]byte) error {
+	return _VmSafe.Contract.AssertEq(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq is a free data retrieval call binding the contract method 0x0cc9ee84.
+//
+// Solidity: function assertEq(bytes32[] left, bytes32[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq(left [][32]byte, right [][32]byte) error {
+	return _VmSafe.Contract.AssertEq(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq0 is a free data retrieval call binding the contract method 0x191f1b30.
+//
+// Solidity: function assertEq(int256[] left, int256[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq0(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq0", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq0 is a free data retrieval call binding the contract method 0x191f1b30.
+//
+// Solidity: function assertEq(int256[] left, int256[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq0(left []*big.Int, right []*big.Int, error string) error {
+	return _VmSafe.Contract.AssertEq0(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq0 is a free data retrieval call binding the contract method 0x191f1b30.
+//
+// Solidity: function assertEq(int256[] left, int256[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq0(left []*big.Int, right []*big.Int, error string) error {
+	return _VmSafe.Contract.AssertEq0(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq1 is a free data retrieval call binding the contract method 0x2f2769d1.
+//
+// Solidity: function assertEq(address left, address right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq1(opts *bind.CallOpts, left common.Address, right common.Address, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq1", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq1 is a free data retrieval call binding the contract method 0x2f2769d1.
+//
+// Solidity: function assertEq(address left, address right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq1(left common.Address, right common.Address, error string) error {
+	return _VmSafe.Contract.AssertEq1(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq1 is a free data retrieval call binding the contract method 0x2f2769d1.
+//
+// Solidity: function assertEq(address left, address right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq1(left common.Address, right common.Address, error string) error {
+	return _VmSafe.Contract.AssertEq1(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq10 is a free data retrieval call binding the contract method 0x714a2f13.
+//
+// Solidity: function assertEq(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq10(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq10", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq10 is a free data retrieval call binding the contract method 0x714a2f13.
+//
+// Solidity: function assertEq(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq10(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertEq10(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq10 is a free data retrieval call binding the contract method 0x714a2f13.
+//
+// Solidity: function assertEq(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq10(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertEq10(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq11 is a free data retrieval call binding the contract method 0x7c84c69b.
+//
+// Solidity: function assertEq(bytes32 left, bytes32 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq11(opts *bind.CallOpts, left [32]byte, right [32]byte) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq11", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq11 is a free data retrieval call binding the contract method 0x7c84c69b.
+//
+// Solidity: function assertEq(bytes32 left, bytes32 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq11(left [32]byte, right [32]byte) error {
+	return _VmSafe.Contract.AssertEq11(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq11 is a free data retrieval call binding the contract method 0x7c84c69b.
+//
+// Solidity: function assertEq(bytes32 left, bytes32 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq11(left [32]byte, right [32]byte) error {
+	return _VmSafe.Contract.AssertEq11(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq12 is a free data retrieval call binding the contract method 0x88b44c85.
+//
+// Solidity: function assertEq(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq12(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq12", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq12 is a free data retrieval call binding the contract method 0x88b44c85.
+//
+// Solidity: function assertEq(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq12(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertEq12(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq12 is a free data retrieval call binding the contract method 0x88b44c85.
+//
+// Solidity: function assertEq(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq12(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertEq12(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq13 is a free data retrieval call binding the contract method 0x975d5a12.
+//
+// Solidity: function assertEq(uint256[] left, uint256[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq13(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq13", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq13 is a free data retrieval call binding the contract method 0x975d5a12.
+//
+// Solidity: function assertEq(uint256[] left, uint256[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq13(left []*big.Int, right []*big.Int) error {
+	return _VmSafe.Contract.AssertEq13(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq13 is a free data retrieval call binding the contract method 0x975d5a12.
+//
+// Solidity: function assertEq(uint256[] left, uint256[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq13(left []*big.Int, right []*big.Int) error {
+	return _VmSafe.Contract.AssertEq13(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq14 is a free data retrieval call binding the contract method 0x97624631.
+//
+// Solidity: function assertEq(bytes left, bytes right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq14(opts *bind.CallOpts, left []byte, right []byte) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq14", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq14 is a free data retrieval call binding the contract method 0x97624631.
+//
+// Solidity: function assertEq(bytes left, bytes right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq14(left []byte, right []byte) error {
+	return _VmSafe.Contract.AssertEq14(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq14 is a free data retrieval call binding the contract method 0x97624631.
+//
+// Solidity: function assertEq(bytes left, bytes right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq14(left []byte, right []byte) error {
+	return _VmSafe.Contract.AssertEq14(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq15 is a free data retrieval call binding the contract method 0x98296c54.
+//
+// Solidity: function assertEq(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq15(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq15", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq15 is a free data retrieval call binding the contract method 0x98296c54.
+//
+// Solidity: function assertEq(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq15(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertEq15(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq15 is a free data retrieval call binding the contract method 0x98296c54.
+//
+// Solidity: function assertEq(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq15(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertEq15(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq16 is a free data retrieval call binding the contract method 0xc1fa1ed0.
+//
+// Solidity: function assertEq(bytes32 left, bytes32 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq16(opts *bind.CallOpts, left [32]byte, right [32]byte, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq16", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq16 is a free data retrieval call binding the contract method 0xc1fa1ed0.
+//
+// Solidity: function assertEq(bytes32 left, bytes32 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq16(left [32]byte, right [32]byte, error string) error {
+	return _VmSafe.Contract.AssertEq16(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq16 is a free data retrieval call binding the contract method 0xc1fa1ed0.
+//
+// Solidity: function assertEq(bytes32 left, bytes32 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq16(left [32]byte, right [32]byte, error string) error {
+	return _VmSafe.Contract.AssertEq16(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq17 is a free data retrieval call binding the contract method 0xcf1c049c.
+//
+// Solidity: function assertEq(string[] left, string[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq17(opts *bind.CallOpts, left []string, right []string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq17", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq17 is a free data retrieval call binding the contract method 0xcf1c049c.
+//
+// Solidity: function assertEq(string[] left, string[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq17(left []string, right []string) error {
+	return _VmSafe.Contract.AssertEq17(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq17 is a free data retrieval call binding the contract method 0xcf1c049c.
+//
+// Solidity: function assertEq(string[] left, string[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq17(left []string, right []string) error {
+	return _VmSafe.Contract.AssertEq17(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq18 is a free data retrieval call binding the contract method 0xe03e9177.
+//
+// Solidity: function assertEq(bytes32[] left, bytes32[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq18(opts *bind.CallOpts, left [][32]byte, right [][32]byte, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq18", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq18 is a free data retrieval call binding the contract method 0xe03e9177.
+//
+// Solidity: function assertEq(bytes32[] left, bytes32[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq18(left [][32]byte, right [][32]byte, error string) error {
+	return _VmSafe.Contract.AssertEq18(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq18 is a free data retrieval call binding the contract method 0xe03e9177.
+//
+// Solidity: function assertEq(bytes32[] left, bytes32[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq18(left [][32]byte, right [][32]byte, error string) error {
+	return _VmSafe.Contract.AssertEq18(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq19 is a free data retrieval call binding the contract method 0xe24fed00.
+//
+// Solidity: function assertEq(bytes left, bytes right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq19(opts *bind.CallOpts, left []byte, right []byte, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq19", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq19 is a free data retrieval call binding the contract method 0xe24fed00.
+//
+// Solidity: function assertEq(bytes left, bytes right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq19(left []byte, right []byte, error string) error {
+	return _VmSafe.Contract.AssertEq19(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq19 is a free data retrieval call binding the contract method 0xe24fed00.
+//
+// Solidity: function assertEq(bytes left, bytes right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq19(left []byte, right []byte, error string) error {
+	return _VmSafe.Contract.AssertEq19(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq2 is a free data retrieval call binding the contract method 0x36f656d8.
+//
+// Solidity: function assertEq(string left, string right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq2(opts *bind.CallOpts, left string, right string, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq2", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq2 is a free data retrieval call binding the contract method 0x36f656d8.
+//
+// Solidity: function assertEq(string left, string right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq2(left string, right string, error string) error {
+	return _VmSafe.Contract.AssertEq2(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq2 is a free data retrieval call binding the contract method 0x36f656d8.
+//
+// Solidity: function assertEq(string left, string right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq2(left string, right string, error string) error {
+	return _VmSafe.Contract.AssertEq2(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq20 is a free data retrieval call binding the contract method 0xe48a8f8d.
+//
+// Solidity: function assertEq(bool[] left, bool[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq20(opts *bind.CallOpts, left []bool, right []bool, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq20", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq20 is a free data retrieval call binding the contract method 0xe48a8f8d.
+//
+// Solidity: function assertEq(bool[] left, bool[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq20(left []bool, right []bool, error string) error {
+	return _VmSafe.Contract.AssertEq20(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq20 is a free data retrieval call binding the contract method 0xe48a8f8d.
+//
+// Solidity: function assertEq(bool[] left, bool[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq20(left []bool, right []bool, error string) error {
+	return _VmSafe.Contract.AssertEq20(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq21 is a free data retrieval call binding the contract method 0xe5fb9b4a.
+//
+// Solidity: function assertEq(bytes[] left, bytes[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq21(opts *bind.CallOpts, left [][]byte, right [][]byte) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq21", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq21 is a free data retrieval call binding the contract method 0xe5fb9b4a.
+//
+// Solidity: function assertEq(bytes[] left, bytes[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq21(left [][]byte, right [][]byte) error {
+	return _VmSafe.Contract.AssertEq21(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq21 is a free data retrieval call binding the contract method 0xe5fb9b4a.
+//
+// Solidity: function assertEq(bytes[] left, bytes[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq21(left [][]byte, right [][]byte) error {
+	return _VmSafe.Contract.AssertEq21(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq22 is a free data retrieval call binding the contract method 0xeff6b27d.
+//
+// Solidity: function assertEq(string[] left, string[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq22(opts *bind.CallOpts, left []string, right []string, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq22", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq22 is a free data retrieval call binding the contract method 0xeff6b27d.
+//
+// Solidity: function assertEq(string[] left, string[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq22(left []string, right []string, error string) error {
+	return _VmSafe.Contract.AssertEq22(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq22 is a free data retrieval call binding the contract method 0xeff6b27d.
+//
+// Solidity: function assertEq(string[] left, string[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq22(left []string, right []string, error string) error {
+	return _VmSafe.Contract.AssertEq22(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq23 is a free data retrieval call binding the contract method 0xf320d963.
+//
+// Solidity: function assertEq(string left, string right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq23(opts *bind.CallOpts, left string, right string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq23", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq23 is a free data retrieval call binding the contract method 0xf320d963.
+//
+// Solidity: function assertEq(string left, string right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq23(left string, right string) error {
+	return _VmSafe.Contract.AssertEq23(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq23 is a free data retrieval call binding the contract method 0xf320d963.
+//
+// Solidity: function assertEq(string left, string right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq23(left string, right string) error {
+	return _VmSafe.Contract.AssertEq23(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq24 is a free data retrieval call binding the contract method 0xf413f0b6.
+//
+// Solidity: function assertEq(bytes[] left, bytes[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq24(opts *bind.CallOpts, left [][]byte, right [][]byte, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq24", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq24 is a free data retrieval call binding the contract method 0xf413f0b6.
+//
+// Solidity: function assertEq(bytes[] left, bytes[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq24(left [][]byte, right [][]byte, error string) error {
+	return _VmSafe.Contract.AssertEq24(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq24 is a free data retrieval call binding the contract method 0xf413f0b6.
+//
+// Solidity: function assertEq(bytes[] left, bytes[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq24(left [][]byte, right [][]byte, error string) error {
+	return _VmSafe.Contract.AssertEq24(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq25 is a free data retrieval call binding the contract method 0xf7fe3477.
+//
+// Solidity: function assertEq(bool left, bool right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq25(opts *bind.CallOpts, left bool, right bool) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq25", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq25 is a free data retrieval call binding the contract method 0xf7fe3477.
+//
+// Solidity: function assertEq(bool left, bool right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq25(left bool, right bool) error {
+	return _VmSafe.Contract.AssertEq25(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq25 is a free data retrieval call binding the contract method 0xf7fe3477.
+//
+// Solidity: function assertEq(bool left, bool right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq25(left bool, right bool) error {
+	return _VmSafe.Contract.AssertEq25(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq26 is a free data retrieval call binding the contract method 0xfe74f05b.
+//
+// Solidity: function assertEq(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq26(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq26", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq26 is a free data retrieval call binding the contract method 0xfe74f05b.
+//
+// Solidity: function assertEq(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq26(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertEq26(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq26 is a free data retrieval call binding the contract method 0xfe74f05b.
+//
+// Solidity: function assertEq(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq26(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertEq26(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq3 is a free data retrieval call binding the contract method 0x3868ac34.
+//
+// Solidity: function assertEq(address[] left, address[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq3(opts *bind.CallOpts, left []common.Address, right []common.Address) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq3", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq3 is a free data retrieval call binding the contract method 0x3868ac34.
+//
+// Solidity: function assertEq(address[] left, address[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq3(left []common.Address, right []common.Address) error {
+	return _VmSafe.Contract.AssertEq3(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq3 is a free data retrieval call binding the contract method 0x3868ac34.
+//
+// Solidity: function assertEq(address[] left, address[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq3(left []common.Address, right []common.Address) error {
+	return _VmSafe.Contract.AssertEq3(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq4 is a free data retrieval call binding the contract method 0x3e9173c5.
+//
+// Solidity: function assertEq(address[] left, address[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq4(opts *bind.CallOpts, left []common.Address, right []common.Address, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq4", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq4 is a free data retrieval call binding the contract method 0x3e9173c5.
+//
+// Solidity: function assertEq(address[] left, address[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq4(left []common.Address, right []common.Address, error string) error {
+	return _VmSafe.Contract.AssertEq4(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq4 is a free data retrieval call binding the contract method 0x3e9173c5.
+//
+// Solidity: function assertEq(address[] left, address[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq4(left []common.Address, right []common.Address, error string) error {
+	return _VmSafe.Contract.AssertEq4(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq5 is a free data retrieval call binding the contract method 0x4db19e7e.
+//
+// Solidity: function assertEq(bool left, bool right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq5(opts *bind.CallOpts, left bool, right bool, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq5", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq5 is a free data retrieval call binding the contract method 0x4db19e7e.
+//
+// Solidity: function assertEq(bool left, bool right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq5(left bool, right bool, error string) error {
+	return _VmSafe.Contract.AssertEq5(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq5 is a free data retrieval call binding the contract method 0x4db19e7e.
+//
+// Solidity: function assertEq(bool left, bool right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq5(left bool, right bool, error string) error {
+	return _VmSafe.Contract.AssertEq5(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq6 is a free data retrieval call binding the contract method 0x515361f6.
+//
+// Solidity: function assertEq(address left, address right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq6(opts *bind.CallOpts, left common.Address, right common.Address) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq6", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq6 is a free data retrieval call binding the contract method 0x515361f6.
+//
+// Solidity: function assertEq(address left, address right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq6(left common.Address, right common.Address) error {
+	return _VmSafe.Contract.AssertEq6(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq6 is a free data retrieval call binding the contract method 0x515361f6.
+//
+// Solidity: function assertEq(address left, address right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq6(left common.Address, right common.Address) error {
+	return _VmSafe.Contract.AssertEq6(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq7 is a free data retrieval call binding the contract method 0x5d18c73a.
+//
+// Solidity: function assertEq(uint256[] left, uint256[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq7(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq7", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq7 is a free data retrieval call binding the contract method 0x5d18c73a.
+//
+// Solidity: function assertEq(uint256[] left, uint256[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq7(left []*big.Int, right []*big.Int, error string) error {
+	return _VmSafe.Contract.AssertEq7(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq7 is a free data retrieval call binding the contract method 0x5d18c73a.
+//
+// Solidity: function assertEq(uint256[] left, uint256[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq7(left []*big.Int, right []*big.Int, error string) error {
+	return _VmSafe.Contract.AssertEq7(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertEq8 is a free data retrieval call binding the contract method 0x707df785.
+//
+// Solidity: function assertEq(bool[] left, bool[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq8(opts *bind.CallOpts, left []bool, right []bool) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq8", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq8 is a free data retrieval call binding the contract method 0x707df785.
+//
+// Solidity: function assertEq(bool[] left, bool[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq8(left []bool, right []bool) error {
+	return _VmSafe.Contract.AssertEq8(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq8 is a free data retrieval call binding the contract method 0x707df785.
+//
+// Solidity: function assertEq(bool[] left, bool[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq8(left []bool, right []bool) error {
+	return _VmSafe.Contract.AssertEq8(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq9 is a free data retrieval call binding the contract method 0x711043ac.
+//
+// Solidity: function assertEq(int256[] left, int256[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEq9(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEq9", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEq9 is a free data retrieval call binding the contract method 0x711043ac.
+//
+// Solidity: function assertEq(int256[] left, int256[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertEq9(left []*big.Int, right []*big.Int) error {
+	return _VmSafe.Contract.AssertEq9(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEq9 is a free data retrieval call binding the contract method 0x711043ac.
+//
+// Solidity: function assertEq(int256[] left, int256[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEq9(left []*big.Int, right []*big.Int) error {
+	return _VmSafe.Contract.AssertEq9(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertEqDecimal is a free data retrieval call binding the contract method 0x27af7d9c.
+//
+// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEqDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEqDecimal", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEqDecimal is a free data retrieval call binding the contract method 0x27af7d9c.
+//
+// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertEqDecimal(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertEqDecimal is a free data retrieval call binding the contract method 0x27af7d9c.
+//
+// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertEqDecimal(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertEqDecimal0 is a free data retrieval call binding the contract method 0x48016c04.
+//
+// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEqDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEqDecimal0", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEqDecimal0 is a free data retrieval call binding the contract method 0x48016c04.
+//
+// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertEqDecimal0(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertEqDecimal0 is a free data retrieval call binding the contract method 0x48016c04.
+//
+// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertEqDecimal0(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertEqDecimal1 is a free data retrieval call binding the contract method 0x7e77b0c5.
+//
+// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEqDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEqDecimal1", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEqDecimal1 is a free data retrieval call binding the contract method 0x7e77b0c5.
+//
+// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertEqDecimal1(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertEqDecimal1 is a free data retrieval call binding the contract method 0x7e77b0c5.
+//
+// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertEqDecimal1(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertEqDecimal2 is a free data retrieval call binding the contract method 0xd0cbbdef.
+//
+// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertEqDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertEqDecimal2", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertEqDecimal2 is a free data retrieval call binding the contract method 0xd0cbbdef.
+//
+// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertEqDecimal2(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertEqDecimal2 is a free data retrieval call binding the contract method 0xd0cbbdef.
+//
+// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertEqDecimal2(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertFalse is a free data retrieval call binding the contract method 0x7ba04809.
+//
+// Solidity: function assertFalse(bool condition, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertFalse(opts *bind.CallOpts, condition bool, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertFalse", condition, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertFalse is a free data retrieval call binding the contract method 0x7ba04809.
+//
+// Solidity: function assertFalse(bool condition, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertFalse(condition bool, error string) error {
+	return _VmSafe.Contract.AssertFalse(&_VmSafe.CallOpts, condition, error)
+}
+
+// AssertFalse is a free data retrieval call binding the contract method 0x7ba04809.
+//
+// Solidity: function assertFalse(bool condition, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertFalse(condition bool, error string) error {
+	return _VmSafe.Contract.AssertFalse(&_VmSafe.CallOpts, condition, error)
+}
+
+// AssertFalse0 is a free data retrieval call binding the contract method 0xa5982885.
+//
+// Solidity: function assertFalse(bool condition) pure returns()
+func (_VmSafe *VmSafeCaller) AssertFalse0(opts *bind.CallOpts, condition bool) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertFalse0", condition)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertFalse0 is a free data retrieval call binding the contract method 0xa5982885.
+//
+// Solidity: function assertFalse(bool condition) pure returns()
+func (_VmSafe *VmSafeSession) AssertFalse0(condition bool) error {
+	return _VmSafe.Contract.AssertFalse0(&_VmSafe.CallOpts, condition)
+}
+
+// AssertFalse0 is a free data retrieval call binding the contract method 0xa5982885.
+//
+// Solidity: function assertFalse(bool condition) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertFalse0(condition bool) error {
+	return _VmSafe.Contract.AssertFalse0(&_VmSafe.CallOpts, condition)
+}
+
+// AssertGe is a free data retrieval call binding the contract method 0x0a30b771.
+//
+// Solidity: function assertGe(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGe(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGe", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGe is a free data retrieval call binding the contract method 0x0a30b771.
+//
+// Solidity: function assertGe(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertGe(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertGe(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertGe is a free data retrieval call binding the contract method 0x0a30b771.
+//
+// Solidity: function assertGe(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGe(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertGe(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertGe0 is a free data retrieval call binding the contract method 0xa84328dd.
+//
+// Solidity: function assertGe(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGe0(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGe0", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGe0 is a free data retrieval call binding the contract method 0xa84328dd.
+//
+// Solidity: function assertGe(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertGe0(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGe0(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertGe0 is a free data retrieval call binding the contract method 0xa84328dd.
+//
+// Solidity: function assertGe(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGe0(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGe0(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertGe1 is a free data retrieval call binding the contract method 0xa8d4d1d9.
+//
+// Solidity: function assertGe(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGe1(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGe1", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGe1 is a free data retrieval call binding the contract method 0xa8d4d1d9.
+//
+// Solidity: function assertGe(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertGe1(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertGe1(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertGe1 is a free data retrieval call binding the contract method 0xa8d4d1d9.
+//
+// Solidity: function assertGe(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGe1(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertGe1(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertGe2 is a free data retrieval call binding the contract method 0xe25242c0.
+//
+// Solidity: function assertGe(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGe2(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGe2", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGe2 is a free data retrieval call binding the contract method 0xe25242c0.
+//
+// Solidity: function assertGe(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertGe2(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGe2(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertGe2 is a free data retrieval call binding the contract method 0xe25242c0.
+//
+// Solidity: function assertGe(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGe2(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGe2(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertGeDecimal is a free data retrieval call binding the contract method 0x3d1fe08a.
+//
+// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGeDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGeDecimal", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGeDecimal is a free data retrieval call binding the contract method 0x3d1fe08a.
+//
+// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertGeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertGeDecimal(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertGeDecimal is a free data retrieval call binding the contract method 0x3d1fe08a.
+//
+// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertGeDecimal(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertGeDecimal0 is a free data retrieval call binding the contract method 0x5df93c9b.
+//
+// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGeDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGeDecimal0", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGeDecimal0 is a free data retrieval call binding the contract method 0x5df93c9b.
+//
+// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertGeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGeDecimal0(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertGeDecimal0 is a free data retrieval call binding the contract method 0x5df93c9b.
+//
+// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGeDecimal0(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertGeDecimal1 is a free data retrieval call binding the contract method 0x8bff9133.
+//
+// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGeDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGeDecimal1", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGeDecimal1 is a free data retrieval call binding the contract method 0x8bff9133.
+//
+// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertGeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGeDecimal1(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertGeDecimal1 is a free data retrieval call binding the contract method 0x8bff9133.
+//
+// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGeDecimal1(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertGeDecimal2 is a free data retrieval call binding the contract method 0xdc28c0f1.
+//
+// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGeDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGeDecimal2", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGeDecimal2 is a free data retrieval call binding the contract method 0xdc28c0f1.
+//
+// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertGeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertGeDecimal2(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertGeDecimal2 is a free data retrieval call binding the contract method 0xdc28c0f1.
+//
+// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertGeDecimal2(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertGt is a free data retrieval call binding the contract method 0x5a362d45.
+//
+// Solidity: function assertGt(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGt(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGt", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGt is a free data retrieval call binding the contract method 0x5a362d45.
+//
+// Solidity: function assertGt(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertGt(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertGt(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertGt is a free data retrieval call binding the contract method 0x5a362d45.
+//
+// Solidity: function assertGt(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGt(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertGt(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertGt0 is a free data retrieval call binding the contract method 0xd9a3c4d2.
+//
+// Solidity: function assertGt(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGt0(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGt0", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGt0 is a free data retrieval call binding the contract method 0xd9a3c4d2.
+//
+// Solidity: function assertGt(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertGt0(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGt0(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertGt0 is a free data retrieval call binding the contract method 0xd9a3c4d2.
+//
+// Solidity: function assertGt(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGt0(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGt0(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertGt1 is a free data retrieval call binding the contract method 0xdb07fcd2.
+//
+// Solidity: function assertGt(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGt1(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGt1", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGt1 is a free data retrieval call binding the contract method 0xdb07fcd2.
+//
+// Solidity: function assertGt(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertGt1(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertGt1(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertGt1 is a free data retrieval call binding the contract method 0xdb07fcd2.
+//
+// Solidity: function assertGt(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGt1(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertGt1(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertGt2 is a free data retrieval call binding the contract method 0xf8d33b9b.
+//
+// Solidity: function assertGt(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGt2(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGt2", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGt2 is a free data retrieval call binding the contract method 0xf8d33b9b.
+//
+// Solidity: function assertGt(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertGt2(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGt2(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertGt2 is a free data retrieval call binding the contract method 0xf8d33b9b.
+//
+// Solidity: function assertGt(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGt2(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGt2(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertGtDecimal is a free data retrieval call binding the contract method 0x04a5c7ab.
+//
+// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGtDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGtDecimal", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGtDecimal is a free data retrieval call binding the contract method 0x04a5c7ab.
+//
+// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertGtDecimal(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGtDecimal(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertGtDecimal is a free data retrieval call binding the contract method 0x04a5c7ab.
+//
+// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGtDecimal(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGtDecimal(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertGtDecimal0 is a free data retrieval call binding the contract method 0x64949a8d.
+//
+// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGtDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGtDecimal0", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGtDecimal0 is a free data retrieval call binding the contract method 0x64949a8d.
+//
+// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertGtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGtDecimal0(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertGtDecimal0 is a free data retrieval call binding the contract method 0x64949a8d.
+//
+// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertGtDecimal0(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertGtDecimal1 is a free data retrieval call binding the contract method 0x78611f0e.
+//
+// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGtDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGtDecimal1", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGtDecimal1 is a free data retrieval call binding the contract method 0x78611f0e.
+//
+// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertGtDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertGtDecimal1(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertGtDecimal1 is a free data retrieval call binding the contract method 0x78611f0e.
+//
+// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGtDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertGtDecimal1(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertGtDecimal2 is a free data retrieval call binding the contract method 0xeccd2437.
+//
+// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertGtDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertGtDecimal2", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertGtDecimal2 is a free data retrieval call binding the contract method 0xeccd2437.
+//
+// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertGtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertGtDecimal2(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertGtDecimal2 is a free data retrieval call binding the contract method 0xeccd2437.
+//
+// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertGtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertGtDecimal2(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertLe is a free data retrieval call binding the contract method 0x4dfe692c.
+//
+// Solidity: function assertLe(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLe(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLe", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLe is a free data retrieval call binding the contract method 0x4dfe692c.
+//
+// Solidity: function assertLe(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertLe(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLe(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertLe is a free data retrieval call binding the contract method 0x4dfe692c.
+//
+// Solidity: function assertLe(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLe(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLe(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertLe0 is a free data retrieval call binding the contract method 0x8466f415.
+//
+// Solidity: function assertLe(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLe0(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLe0", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLe0 is a free data retrieval call binding the contract method 0x8466f415.
+//
+// Solidity: function assertLe(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertLe0(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertLe0(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertLe0 is a free data retrieval call binding the contract method 0x8466f415.
+//
+// Solidity: function assertLe(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLe0(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertLe0(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertLe1 is a free data retrieval call binding the contract method 0x95fd154e.
+//
+// Solidity: function assertLe(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLe1(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLe1", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLe1 is a free data retrieval call binding the contract method 0x95fd154e.
+//
+// Solidity: function assertLe(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertLe1(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertLe1(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertLe1 is a free data retrieval call binding the contract method 0x95fd154e.
+//
+// Solidity: function assertLe(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLe1(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertLe1(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertLe2 is a free data retrieval call binding the contract method 0xd17d4b0d.
+//
+// Solidity: function assertLe(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLe2(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLe2", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLe2 is a free data retrieval call binding the contract method 0xd17d4b0d.
+//
+// Solidity: function assertLe(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertLe2(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLe2(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertLe2 is a free data retrieval call binding the contract method 0xd17d4b0d.
+//
+// Solidity: function assertLe(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLe2(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLe2(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertLeDecimal is a free data retrieval call binding the contract method 0x11d1364a.
+//
+// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLeDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLeDecimal", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLeDecimal is a free data retrieval call binding the contract method 0x11d1364a.
+//
+// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertLeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertLeDecimal(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertLeDecimal is a free data retrieval call binding the contract method 0x11d1364a.
+//
+// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertLeDecimal(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertLeDecimal0 is a free data retrieval call binding the contract method 0x7fefbbe0.
+//
+// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLeDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLeDecimal0", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLeDecimal0 is a free data retrieval call binding the contract method 0x7fefbbe0.
+//
+// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertLeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLeDecimal0(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertLeDecimal0 is a free data retrieval call binding the contract method 0x7fefbbe0.
+//
+// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLeDecimal0(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertLeDecimal1 is a free data retrieval call binding the contract method 0xaa5cf788.
+//
+// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLeDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLeDecimal1", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLeDecimal1 is a free data retrieval call binding the contract method 0xaa5cf788.
+//
+// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertLeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLeDecimal1(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertLeDecimal1 is a free data retrieval call binding the contract method 0xaa5cf788.
+//
+// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLeDecimal1(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertLeDecimal2 is a free data retrieval call binding the contract method 0xc304aab7.
+//
+// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLeDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLeDecimal2", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLeDecimal2 is a free data retrieval call binding the contract method 0xc304aab7.
+//
+// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertLeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertLeDecimal2(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertLeDecimal2 is a free data retrieval call binding the contract method 0xc304aab7.
+//
+// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertLeDecimal2(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertLt is a free data retrieval call binding the contract method 0x3e914080.
+//
+// Solidity: function assertLt(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLt(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLt", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLt is a free data retrieval call binding the contract method 0x3e914080.
+//
+// Solidity: function assertLt(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertLt(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertLt(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertLt is a free data retrieval call binding the contract method 0x3e914080.
+//
+// Solidity: function assertLt(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLt(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertLt(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertLt0 is a free data retrieval call binding the contract method 0x65d5c135.
+//
+// Solidity: function assertLt(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLt0(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLt0", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLt0 is a free data retrieval call binding the contract method 0x65d5c135.
+//
+// Solidity: function assertLt(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertLt0(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLt0(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertLt0 is a free data retrieval call binding the contract method 0x65d5c135.
+//
+// Solidity: function assertLt(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLt0(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLt0(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertLt1 is a free data retrieval call binding the contract method 0x9ff531e3.
+//
+// Solidity: function assertLt(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLt1(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLt1", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLt1 is a free data retrieval call binding the contract method 0x9ff531e3.
+//
+// Solidity: function assertLt(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertLt1(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLt1(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertLt1 is a free data retrieval call binding the contract method 0x9ff531e3.
+//
+// Solidity: function assertLt(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLt1(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLt1(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertLt2 is a free data retrieval call binding the contract method 0xb12fc005.
+//
+// Solidity: function assertLt(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLt2(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLt2", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLt2 is a free data retrieval call binding the contract method 0xb12fc005.
+//
+// Solidity: function assertLt(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertLt2(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertLt2(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertLt2 is a free data retrieval call binding the contract method 0xb12fc005.
+//
+// Solidity: function assertLt(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLt2(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertLt2(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertLtDecimal is a free data retrieval call binding the contract method 0x2077337e.
+//
+// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLtDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLtDecimal", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLtDecimal is a free data retrieval call binding the contract method 0x2077337e.
+//
+// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertLtDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertLtDecimal(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertLtDecimal is a free data retrieval call binding the contract method 0x2077337e.
+//
+// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLtDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertLtDecimal(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertLtDecimal0 is a free data retrieval call binding the contract method 0x40f0b4e0.
+//
+// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLtDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLtDecimal0", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLtDecimal0 is a free data retrieval call binding the contract method 0x40f0b4e0.
+//
+// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertLtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLtDecimal0(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertLtDecimal0 is a free data retrieval call binding the contract method 0x40f0b4e0.
+//
+// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLtDecimal0(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertLtDecimal1 is a free data retrieval call binding the contract method 0xa972d037.
+//
+// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLtDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLtDecimal1", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLtDecimal1 is a free data retrieval call binding the contract method 0xa972d037.
+//
+// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertLtDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLtDecimal1(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertLtDecimal1 is a free data retrieval call binding the contract method 0xa972d037.
+//
+// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLtDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertLtDecimal1(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertLtDecimal2 is a free data retrieval call binding the contract method 0xdbe8d88b.
+//
+// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertLtDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertLtDecimal2", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertLtDecimal2 is a free data retrieval call binding the contract method 0xdbe8d88b.
+//
+// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertLtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertLtDecimal2(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertLtDecimal2 is a free data retrieval call binding the contract method 0xdbe8d88b.
+//
+// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertLtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertLtDecimal2(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertNotEq is a free data retrieval call binding the contract method 0x0603ea68.
+//
+// Solidity: function assertNotEq(bytes32[] left, bytes32[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq(opts *bind.CallOpts, left [][32]byte, right [][32]byte) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq is a free data retrieval call binding the contract method 0x0603ea68.
+//
+// Solidity: function assertNotEq(bytes32[] left, bytes32[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq(left [][32]byte, right [][32]byte) error {
+	return _VmSafe.Contract.AssertNotEq(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq is a free data retrieval call binding the contract method 0x0603ea68.
+//
+// Solidity: function assertNotEq(bytes32[] left, bytes32[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq(left [][32]byte, right [][32]byte) error {
+	return _VmSafe.Contract.AssertNotEq(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq0 is a free data retrieval call binding the contract method 0x0b72f4ef.
+//
+// Solidity: function assertNotEq(int256[] left, int256[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq0(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq0", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq0 is a free data retrieval call binding the contract method 0x0b72f4ef.
+//
+// Solidity: function assertNotEq(int256[] left, int256[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq0(left []*big.Int, right []*big.Int) error {
+	return _VmSafe.Contract.AssertNotEq0(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq0 is a free data retrieval call binding the contract method 0x0b72f4ef.
+//
+// Solidity: function assertNotEq(int256[] left, int256[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq0(left []*big.Int, right []*big.Int) error {
+	return _VmSafe.Contract.AssertNotEq0(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq1 is a free data retrieval call binding the contract method 0x1091a261.
+//
+// Solidity: function assertNotEq(bool left, bool right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq1(opts *bind.CallOpts, left bool, right bool, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq1", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq1 is a free data retrieval call binding the contract method 0x1091a261.
+//
+// Solidity: function assertNotEq(bool left, bool right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq1(left bool, right bool, error string) error {
+	return _VmSafe.Contract.AssertNotEq1(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq1 is a free data retrieval call binding the contract method 0x1091a261.
+//
+// Solidity: function assertNotEq(bool left, bool right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq1(left bool, right bool, error string) error {
+	return _VmSafe.Contract.AssertNotEq1(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq10 is a free data retrieval call binding the contract method 0x6a8237b3.
+//
+// Solidity: function assertNotEq(string left, string right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq10(opts *bind.CallOpts, left string, right string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq10", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq10 is a free data retrieval call binding the contract method 0x6a8237b3.
+//
+// Solidity: function assertNotEq(string left, string right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq10(left string, right string) error {
+	return _VmSafe.Contract.AssertNotEq10(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq10 is a free data retrieval call binding the contract method 0x6a8237b3.
+//
+// Solidity: function assertNotEq(string left, string right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq10(left string, right string) error {
+	return _VmSafe.Contract.AssertNotEq10(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq11 is a free data retrieval call binding the contract method 0x72c7e0b5.
+//
+// Solidity: function assertNotEq(address[] left, address[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq11(opts *bind.CallOpts, left []common.Address, right []common.Address, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq11", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq11 is a free data retrieval call binding the contract method 0x72c7e0b5.
+//
+// Solidity: function assertNotEq(address[] left, address[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq11(left []common.Address, right []common.Address, error string) error {
+	return _VmSafe.Contract.AssertNotEq11(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq11 is a free data retrieval call binding the contract method 0x72c7e0b5.
+//
+// Solidity: function assertNotEq(address[] left, address[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq11(left []common.Address, right []common.Address, error string) error {
+	return _VmSafe.Contract.AssertNotEq11(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq12 is a free data retrieval call binding the contract method 0x78bdcea7.
+//
+// Solidity: function assertNotEq(string left, string right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq12(opts *bind.CallOpts, left string, right string, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq12", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq12 is a free data retrieval call binding the contract method 0x78bdcea7.
+//
+// Solidity: function assertNotEq(string left, string right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq12(left string, right string, error string) error {
+	return _VmSafe.Contract.AssertNotEq12(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq12 is a free data retrieval call binding the contract method 0x78bdcea7.
+//
+// Solidity: function assertNotEq(string left, string right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq12(left string, right string, error string) error {
+	return _VmSafe.Contract.AssertNotEq12(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq13 is a free data retrieval call binding the contract method 0x8775a591.
+//
+// Solidity: function assertNotEq(address left, address right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq13(opts *bind.CallOpts, left common.Address, right common.Address, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq13", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq13 is a free data retrieval call binding the contract method 0x8775a591.
+//
+// Solidity: function assertNotEq(address left, address right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq13(left common.Address, right common.Address, error string) error {
+	return _VmSafe.Contract.AssertNotEq13(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq13 is a free data retrieval call binding the contract method 0x8775a591.
+//
+// Solidity: function assertNotEq(address left, address right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq13(left common.Address, right common.Address, error string) error {
+	return _VmSafe.Contract.AssertNotEq13(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq14 is a free data retrieval call binding the contract method 0x898e83fc.
+//
+// Solidity: function assertNotEq(bytes32 left, bytes32 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq14(opts *bind.CallOpts, left [32]byte, right [32]byte) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq14", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq14 is a free data retrieval call binding the contract method 0x898e83fc.
+//
+// Solidity: function assertNotEq(bytes32 left, bytes32 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq14(left [32]byte, right [32]byte) error {
+	return _VmSafe.Contract.AssertNotEq14(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq14 is a free data retrieval call binding the contract method 0x898e83fc.
+//
+// Solidity: function assertNotEq(bytes32 left, bytes32 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq14(left [32]byte, right [32]byte) error {
+	return _VmSafe.Contract.AssertNotEq14(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq15 is a free data retrieval call binding the contract method 0x9507540e.
+//
+// Solidity: function assertNotEq(bytes left, bytes right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq15(opts *bind.CallOpts, left []byte, right []byte, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq15", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq15 is a free data retrieval call binding the contract method 0x9507540e.
+//
+// Solidity: function assertNotEq(bytes left, bytes right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq15(left []byte, right []byte, error string) error {
+	return _VmSafe.Contract.AssertNotEq15(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq15 is a free data retrieval call binding the contract method 0x9507540e.
+//
+// Solidity: function assertNotEq(bytes left, bytes right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq15(left []byte, right []byte, error string) error {
+	return _VmSafe.Contract.AssertNotEq15(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq16 is a free data retrieval call binding the contract method 0x98f9bdbd.
+//
+// Solidity: function assertNotEq(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq16(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq16", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq16 is a free data retrieval call binding the contract method 0x98f9bdbd.
+//
+// Solidity: function assertNotEq(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq16(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertNotEq16(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq16 is a free data retrieval call binding the contract method 0x98f9bdbd.
+//
+// Solidity: function assertNotEq(uint256 left, uint256 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq16(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertNotEq16(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq17 is a free data retrieval call binding the contract method 0x9a7fbd8f.
+//
+// Solidity: function assertNotEq(uint256[] left, uint256[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq17(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq17", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq17 is a free data retrieval call binding the contract method 0x9a7fbd8f.
+//
+// Solidity: function assertNotEq(uint256[] left, uint256[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq17(left []*big.Int, right []*big.Int, error string) error {
+	return _VmSafe.Contract.AssertNotEq17(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq17 is a free data retrieval call binding the contract method 0x9a7fbd8f.
+//
+// Solidity: function assertNotEq(uint256[] left, uint256[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq17(left []*big.Int, right []*big.Int, error string) error {
+	return _VmSafe.Contract.AssertNotEq17(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq18 is a free data retrieval call binding the contract method 0xb12e1694.
+//
+// Solidity: function assertNotEq(address left, address right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq18(opts *bind.CallOpts, left common.Address, right common.Address) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq18", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq18 is a free data retrieval call binding the contract method 0xb12e1694.
+//
+// Solidity: function assertNotEq(address left, address right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq18(left common.Address, right common.Address) error {
+	return _VmSafe.Contract.AssertNotEq18(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq18 is a free data retrieval call binding the contract method 0xb12e1694.
+//
+// Solidity: function assertNotEq(address left, address right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq18(left common.Address, right common.Address) error {
+	return _VmSafe.Contract.AssertNotEq18(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq19 is a free data retrieval call binding the contract method 0xb2332f51.
+//
+// Solidity: function assertNotEq(bytes32 left, bytes32 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq19(opts *bind.CallOpts, left [32]byte, right [32]byte, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq19", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq19 is a free data retrieval call binding the contract method 0xb2332f51.
+//
+// Solidity: function assertNotEq(bytes32 left, bytes32 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq19(left [32]byte, right [32]byte, error string) error {
+	return _VmSafe.Contract.AssertNotEq19(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq19 is a free data retrieval call binding the contract method 0xb2332f51.
+//
+// Solidity: function assertNotEq(bytes32 left, bytes32 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq19(left [32]byte, right [32]byte, error string) error {
+	return _VmSafe.Contract.AssertNotEq19(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq2 is a free data retrieval call binding the contract method 0x1dcd1f68.
+//
+// Solidity: function assertNotEq(bytes[] left, bytes[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq2(opts *bind.CallOpts, left [][]byte, right [][]byte, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq2", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq2 is a free data retrieval call binding the contract method 0x1dcd1f68.
+//
+// Solidity: function assertNotEq(bytes[] left, bytes[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq2(left [][]byte, right [][]byte, error string) error {
+	return _VmSafe.Contract.AssertNotEq2(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq2 is a free data retrieval call binding the contract method 0x1dcd1f68.
+//
+// Solidity: function assertNotEq(bytes[] left, bytes[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq2(left [][]byte, right [][]byte, error string) error {
+	return _VmSafe.Contract.AssertNotEq2(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq20 is a free data retrieval call binding the contract method 0xb67187f3.
+//
+// Solidity: function assertNotEq(string[] left, string[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq20(opts *bind.CallOpts, left []string, right []string, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq20", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq20 is a free data retrieval call binding the contract method 0xb67187f3.
+//
+// Solidity: function assertNotEq(string[] left, string[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq20(left []string, right []string, error string) error {
+	return _VmSafe.Contract.AssertNotEq20(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq20 is a free data retrieval call binding the contract method 0xb67187f3.
+//
+// Solidity: function assertNotEq(string[] left, string[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq20(left []string, right []string, error string) error {
+	return _VmSafe.Contract.AssertNotEq20(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq21 is a free data retrieval call binding the contract method 0xb7909320.
+//
+// Solidity: function assertNotEq(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq21(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq21", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq21 is a free data retrieval call binding the contract method 0xb7909320.
+//
+// Solidity: function assertNotEq(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq21(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertNotEq21(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq21 is a free data retrieval call binding the contract method 0xb7909320.
+//
+// Solidity: function assertNotEq(uint256 left, uint256 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq21(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertNotEq21(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq22 is a free data retrieval call binding the contract method 0xb873634c.
+//
+// Solidity: function assertNotEq(bytes32[] left, bytes32[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq22(opts *bind.CallOpts, left [][32]byte, right [][32]byte, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq22", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq22 is a free data retrieval call binding the contract method 0xb873634c.
+//
+// Solidity: function assertNotEq(bytes32[] left, bytes32[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq22(left [][32]byte, right [][32]byte, error string) error {
+	return _VmSafe.Contract.AssertNotEq22(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq22 is a free data retrieval call binding the contract method 0xb873634c.
+//
+// Solidity: function assertNotEq(bytes32[] left, bytes32[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq22(left [][32]byte, right [][32]byte, error string) error {
+	return _VmSafe.Contract.AssertNotEq22(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq23 is a free data retrieval call binding the contract method 0xbdfacbe8.
+//
+// Solidity: function assertNotEq(string[] left, string[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq23(opts *bind.CallOpts, left []string, right []string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq23", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq23 is a free data retrieval call binding the contract method 0xbdfacbe8.
+//
+// Solidity: function assertNotEq(string[] left, string[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq23(left []string, right []string) error {
+	return _VmSafe.Contract.AssertNotEq23(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq23 is a free data retrieval call binding the contract method 0xbdfacbe8.
+//
+// Solidity: function assertNotEq(string[] left, string[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq23(left []string, right []string) error {
+	return _VmSafe.Contract.AssertNotEq23(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq24 is a free data retrieval call binding the contract method 0xd3977322.
+//
+// Solidity: function assertNotEq(int256[] left, int256[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq24(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq24", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq24 is a free data retrieval call binding the contract method 0xd3977322.
+//
+// Solidity: function assertNotEq(int256[] left, int256[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq24(left []*big.Int, right []*big.Int, error string) error {
+	return _VmSafe.Contract.AssertNotEq24(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq24 is a free data retrieval call binding the contract method 0xd3977322.
+//
+// Solidity: function assertNotEq(int256[] left, int256[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq24(left []*big.Int, right []*big.Int, error string) error {
+	return _VmSafe.Contract.AssertNotEq24(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq25 is a free data retrieval call binding the contract method 0xedecd035.
+//
+// Solidity: function assertNotEq(bytes[] left, bytes[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq25(opts *bind.CallOpts, left [][]byte, right [][]byte) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq25", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq25 is a free data retrieval call binding the contract method 0xedecd035.
+//
+// Solidity: function assertNotEq(bytes[] left, bytes[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq25(left [][]byte, right [][]byte) error {
+	return _VmSafe.Contract.AssertNotEq25(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq25 is a free data retrieval call binding the contract method 0xedecd035.
+//
+// Solidity: function assertNotEq(bytes[] left, bytes[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq25(left [][]byte, right [][]byte) error {
+	return _VmSafe.Contract.AssertNotEq25(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq26 is a free data retrieval call binding the contract method 0xf4c004e3.
+//
+// Solidity: function assertNotEq(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq26(opts *bind.CallOpts, left *big.Int, right *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq26", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq26 is a free data retrieval call binding the contract method 0xf4c004e3.
+//
+// Solidity: function assertNotEq(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq26(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertNotEq26(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq26 is a free data retrieval call binding the contract method 0xf4c004e3.
+//
+// Solidity: function assertNotEq(int256 left, int256 right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq26(left *big.Int, right *big.Int) error {
+	return _VmSafe.Contract.AssertNotEq26(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq3 is a free data retrieval call binding the contract method 0x236e4d66.
+//
+// Solidity: function assertNotEq(bool left, bool right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq3(opts *bind.CallOpts, left bool, right bool) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq3", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq3 is a free data retrieval call binding the contract method 0x236e4d66.
+//
+// Solidity: function assertNotEq(bool left, bool right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq3(left bool, right bool) error {
+	return _VmSafe.Contract.AssertNotEq3(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq3 is a free data retrieval call binding the contract method 0x236e4d66.
+//
+// Solidity: function assertNotEq(bool left, bool right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq3(left bool, right bool) error {
+	return _VmSafe.Contract.AssertNotEq3(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq4 is a free data retrieval call binding the contract method 0x286fafea.
+//
+// Solidity: function assertNotEq(bool[] left, bool[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq4(opts *bind.CallOpts, left []bool, right []bool) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq4", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq4 is a free data retrieval call binding the contract method 0x286fafea.
+//
+// Solidity: function assertNotEq(bool[] left, bool[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq4(left []bool, right []bool) error {
+	return _VmSafe.Contract.AssertNotEq4(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq4 is a free data retrieval call binding the contract method 0x286fafea.
+//
+// Solidity: function assertNotEq(bool[] left, bool[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq4(left []bool, right []bool) error {
+	return _VmSafe.Contract.AssertNotEq4(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq5 is a free data retrieval call binding the contract method 0x3cf78e28.
+//
+// Solidity: function assertNotEq(bytes left, bytes right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq5(opts *bind.CallOpts, left []byte, right []byte) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq5", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq5 is a free data retrieval call binding the contract method 0x3cf78e28.
+//
+// Solidity: function assertNotEq(bytes left, bytes right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq5(left []byte, right []byte) error {
+	return _VmSafe.Contract.AssertNotEq5(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq5 is a free data retrieval call binding the contract method 0x3cf78e28.
+//
+// Solidity: function assertNotEq(bytes left, bytes right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq5(left []byte, right []byte) error {
+	return _VmSafe.Contract.AssertNotEq5(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq6 is a free data retrieval call binding the contract method 0x46d0b252.
+//
+// Solidity: function assertNotEq(address[] left, address[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq6(opts *bind.CallOpts, left []common.Address, right []common.Address) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq6", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq6 is a free data retrieval call binding the contract method 0x46d0b252.
+//
+// Solidity: function assertNotEq(address[] left, address[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq6(left []common.Address, right []common.Address) error {
+	return _VmSafe.Contract.AssertNotEq6(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq6 is a free data retrieval call binding the contract method 0x46d0b252.
+//
+// Solidity: function assertNotEq(address[] left, address[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq6(left []common.Address, right []common.Address) error {
+	return _VmSafe.Contract.AssertNotEq6(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq7 is a free data retrieval call binding the contract method 0x4724c5b9.
+//
+// Solidity: function assertNotEq(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq7(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq7", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq7 is a free data retrieval call binding the contract method 0x4724c5b9.
+//
+// Solidity: function assertNotEq(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq7(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertNotEq7(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq7 is a free data retrieval call binding the contract method 0x4724c5b9.
+//
+// Solidity: function assertNotEq(int256 left, int256 right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq7(left *big.Int, right *big.Int, error string) error {
+	return _VmSafe.Contract.AssertNotEq7(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq8 is a free data retrieval call binding the contract method 0x56f29cba.
+//
+// Solidity: function assertNotEq(uint256[] left, uint256[] right) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq8(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq8", left, right)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq8 is a free data retrieval call binding the contract method 0x56f29cba.
+//
+// Solidity: function assertNotEq(uint256[] left, uint256[] right) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq8(left []*big.Int, right []*big.Int) error {
+	return _VmSafe.Contract.AssertNotEq8(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq8 is a free data retrieval call binding the contract method 0x56f29cba.
+//
+// Solidity: function assertNotEq(uint256[] left, uint256[] right) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq8(left []*big.Int, right []*big.Int) error {
+	return _VmSafe.Contract.AssertNotEq8(&_VmSafe.CallOpts, left, right)
+}
+
+// AssertNotEq9 is a free data retrieval call binding the contract method 0x62c6f9fb.
+//
+// Solidity: function assertNotEq(bool[] left, bool[] right, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEq9(opts *bind.CallOpts, left []bool, right []bool, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEq9", left, right, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEq9 is a free data retrieval call binding the contract method 0x62c6f9fb.
+//
+// Solidity: function assertNotEq(bool[] left, bool[] right, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEq9(left []bool, right []bool, error string) error {
+	return _VmSafe.Contract.AssertNotEq9(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEq9 is a free data retrieval call binding the contract method 0x62c6f9fb.
+//
+// Solidity: function assertNotEq(bool[] left, bool[] right, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEq9(left []bool, right []bool, error string) error {
+	return _VmSafe.Contract.AssertNotEq9(&_VmSafe.CallOpts, left, right, error)
+}
+
+// AssertNotEqDecimal is a free data retrieval call binding the contract method 0x14e75680.
+//
+// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEqDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEqDecimal", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEqDecimal is a free data retrieval call binding the contract method 0x14e75680.
+//
+// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertNotEqDecimal(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertNotEqDecimal is a free data retrieval call binding the contract method 0x14e75680.
+//
+// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertNotEqDecimal(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertNotEqDecimal0 is a free data retrieval call binding the contract method 0x33949f0b.
+//
+// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEqDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEqDecimal0", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEqDecimal0 is a free data retrieval call binding the contract method 0x33949f0b.
+//
+// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertNotEqDecimal0(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertNotEqDecimal0 is a free data retrieval call binding the contract method 0x33949f0b.
+//
+// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertNotEqDecimal0(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertNotEqDecimal1 is a free data retrieval call binding the contract method 0x669efca7.
+//
+// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEqDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEqDecimal1", left, right, decimals)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEqDecimal1 is a free data retrieval call binding the contract method 0x669efca7.
+//
+// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertNotEqDecimal1(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertNotEqDecimal1 is a free data retrieval call binding the contract method 0x669efca7.
+//
+// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error {
+	return _VmSafe.Contract.AssertNotEqDecimal1(&_VmSafe.CallOpts, left, right, decimals)
+}
+
+// AssertNotEqDecimal2 is a free data retrieval call binding the contract method 0xf5a55558.
+//
+// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertNotEqDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertNotEqDecimal2", left, right, decimals, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertNotEqDecimal2 is a free data retrieval call binding the contract method 0xf5a55558.
+//
+// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertNotEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertNotEqDecimal2(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertNotEqDecimal2 is a free data retrieval call binding the contract method 0xf5a55558.
+//
+// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertNotEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error {
+	return _VmSafe.Contract.AssertNotEqDecimal2(&_VmSafe.CallOpts, left, right, decimals, error)
+}
+
+// AssertTrue is a free data retrieval call binding the contract method 0x0c9fd581.
+//
+// Solidity: function assertTrue(bool condition) pure returns()
+func (_VmSafe *VmSafeCaller) AssertTrue(opts *bind.CallOpts, condition bool) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertTrue", condition)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertTrue is a free data retrieval call binding the contract method 0x0c9fd581.
+//
+// Solidity: function assertTrue(bool condition) pure returns()
+func (_VmSafe *VmSafeSession) AssertTrue(condition bool) error {
+	return _VmSafe.Contract.AssertTrue(&_VmSafe.CallOpts, condition)
+}
+
+// AssertTrue is a free data retrieval call binding the contract method 0x0c9fd581.
+//
+// Solidity: function assertTrue(bool condition) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertTrue(condition bool) error {
+	return _VmSafe.Contract.AssertTrue(&_VmSafe.CallOpts, condition)
+}
+
+// AssertTrue0 is a free data retrieval call binding the contract method 0xa34edc03.
+//
+// Solidity: function assertTrue(bool condition, string error) pure returns()
+func (_VmSafe *VmSafeCaller) AssertTrue0(opts *bind.CallOpts, condition bool, error string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assertTrue0", condition, error)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssertTrue0 is a free data retrieval call binding the contract method 0xa34edc03.
+//
+// Solidity: function assertTrue(bool condition, string error) pure returns()
+func (_VmSafe *VmSafeSession) AssertTrue0(condition bool, error string) error {
+	return _VmSafe.Contract.AssertTrue0(&_VmSafe.CallOpts, condition, error)
+}
+
+// AssertTrue0 is a free data retrieval call binding the contract method 0xa34edc03.
+//
+// Solidity: function assertTrue(bool condition, string error) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssertTrue0(condition bool, error string) error {
+	return _VmSafe.Contract.AssertTrue0(&_VmSafe.CallOpts, condition, error)
+}
+
+// Assume is a free data retrieval call binding the contract method 0x4c63e562.
+//
+// Solidity: function assume(bool condition) pure returns()
+func (_VmSafe *VmSafeCaller) Assume(opts *bind.CallOpts, condition bool) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assume", condition)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// Assume is a free data retrieval call binding the contract method 0x4c63e562.
+//
+// Solidity: function assume(bool condition) pure returns()
+func (_VmSafe *VmSafeSession) Assume(condition bool) error {
+	return _VmSafe.Contract.Assume(&_VmSafe.CallOpts, condition)
+}
+
+// Assume is a free data retrieval call binding the contract method 0x4c63e562.
+//
+// Solidity: function assume(bool condition) pure returns()
+func (_VmSafe *VmSafeCallerSession) Assume(condition bool) error {
+	return _VmSafe.Contract.Assume(&_VmSafe.CallOpts, condition)
+}
+
+// AssumeNoRevert is a free data retrieval call binding the contract method 0x285b366a.
+//
+// Solidity: function assumeNoRevert() pure returns()
+func (_VmSafe *VmSafeCaller) AssumeNoRevert(opts *bind.CallOpts) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assumeNoRevert")
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssumeNoRevert is a free data retrieval call binding the contract method 0x285b366a.
+//
+// Solidity: function assumeNoRevert() pure returns()
+func (_VmSafe *VmSafeSession) AssumeNoRevert() error {
+	return _VmSafe.Contract.AssumeNoRevert(&_VmSafe.CallOpts)
+}
+
+// AssumeNoRevert is a free data retrieval call binding the contract method 0x285b366a.
+//
+// Solidity: function assumeNoRevert() pure returns()
+func (_VmSafe *VmSafeCallerSession) AssumeNoRevert() error {
+	return _VmSafe.Contract.AssumeNoRevert(&_VmSafe.CallOpts)
+}
+
+// AssumeNoRevert0 is a free data retrieval call binding the contract method 0x8a4592cc.
+//
+// Solidity: function assumeNoRevert((address,bool,bytes)[] potentialReverts) pure returns()
+func (_VmSafe *VmSafeCaller) AssumeNoRevert0(opts *bind.CallOpts, potentialReverts []VmSafePotentialRevert) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assumeNoRevert0", potentialReverts)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssumeNoRevert0 is a free data retrieval call binding the contract method 0x8a4592cc.
+//
+// Solidity: function assumeNoRevert((address,bool,bytes)[] potentialReverts) pure returns()
+func (_VmSafe *VmSafeSession) AssumeNoRevert0(potentialReverts []VmSafePotentialRevert) error {
+	return _VmSafe.Contract.AssumeNoRevert0(&_VmSafe.CallOpts, potentialReverts)
+}
+
+// AssumeNoRevert0 is a free data retrieval call binding the contract method 0x8a4592cc.
+//
+// Solidity: function assumeNoRevert((address,bool,bytes)[] potentialReverts) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssumeNoRevert0(potentialReverts []VmSafePotentialRevert) error {
+	return _VmSafe.Contract.AssumeNoRevert0(&_VmSafe.CallOpts, potentialReverts)
+}
+
+// AssumeNoRevert1 is a free data retrieval call binding the contract method 0xd8591eeb.
+//
+// Solidity: function assumeNoRevert((address,bool,bytes) potentialRevert) pure returns()
+func (_VmSafe *VmSafeCaller) AssumeNoRevert1(opts *bind.CallOpts, potentialRevert VmSafePotentialRevert) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "assumeNoRevert1", potentialRevert)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// AssumeNoRevert1 is a free data retrieval call binding the contract method 0xd8591eeb.
+//
+// Solidity: function assumeNoRevert((address,bool,bytes) potentialRevert) pure returns()
+func (_VmSafe *VmSafeSession) AssumeNoRevert1(potentialRevert VmSafePotentialRevert) error {
+	return _VmSafe.Contract.AssumeNoRevert1(&_VmSafe.CallOpts, potentialRevert)
+}
+
+// AssumeNoRevert1 is a free data retrieval call binding the contract method 0xd8591eeb.
+//
+// Solidity: function assumeNoRevert((address,bool,bytes) potentialRevert) pure returns()
+func (_VmSafe *VmSafeCallerSession) AssumeNoRevert1(potentialRevert VmSafePotentialRevert) error {
+	return _VmSafe.Contract.AssumeNoRevert1(&_VmSafe.CallOpts, potentialRevert)
+}
+
+// Breakpoint is a free data retrieval call binding the contract method 0xf0259e92.
+//
+// Solidity: function breakpoint(string char) pure returns()
+func (_VmSafe *VmSafeCaller) Breakpoint(opts *bind.CallOpts, char string) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "breakpoint", char)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// Breakpoint is a free data retrieval call binding the contract method 0xf0259e92.
+//
+// Solidity: function breakpoint(string char) pure returns()
+func (_VmSafe *VmSafeSession) Breakpoint(char string) error {
+	return _VmSafe.Contract.Breakpoint(&_VmSafe.CallOpts, char)
+}
+
+// Breakpoint is a free data retrieval call binding the contract method 0xf0259e92.
+//
+// Solidity: function breakpoint(string char) pure returns()
+func (_VmSafe *VmSafeCallerSession) Breakpoint(char string) error {
+	return _VmSafe.Contract.Breakpoint(&_VmSafe.CallOpts, char)
+}
+
+// Breakpoint0 is a free data retrieval call binding the contract method 0xf7d39a8d.
+//
+// Solidity: function breakpoint(string char, bool value) pure returns()
+func (_VmSafe *VmSafeCaller) Breakpoint0(opts *bind.CallOpts, char string, value bool) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "breakpoint0", char, value)
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// Breakpoint0 is a free data retrieval call binding the contract method 0xf7d39a8d.
+//
+// Solidity: function breakpoint(string char, bool value) pure returns()
+func (_VmSafe *VmSafeSession) Breakpoint0(char string, value bool) error {
+	return _VmSafe.Contract.Breakpoint0(&_VmSafe.CallOpts, char, value)
+}
+
+// Breakpoint0 is a free data retrieval call binding the contract method 0xf7d39a8d.
+//
+// Solidity: function breakpoint(string char, bool value) pure returns()
+func (_VmSafe *VmSafeCallerSession) Breakpoint0(char string, value bool) error {
+	return _VmSafe.Contract.Breakpoint0(&_VmSafe.CallOpts, char, value)
+}
+
+// ComputeCreate2Address is a free data retrieval call binding the contract method 0x890c283b.
+//
+// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) pure returns(address)
+func (_VmSafe *VmSafeCaller) ComputeCreate2Address(opts *bind.CallOpts, salt [32]byte, initCodeHash [32]byte) (common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "computeCreate2Address", salt, initCodeHash)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// ComputeCreate2Address is a free data retrieval call binding the contract method 0x890c283b.
+//
+// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) pure returns(address)
+func (_VmSafe *VmSafeSession) ComputeCreate2Address(salt [32]byte, initCodeHash [32]byte) (common.Address, error) {
+	return _VmSafe.Contract.ComputeCreate2Address(&_VmSafe.CallOpts, salt, initCodeHash)
+}
+
+// ComputeCreate2Address is a free data retrieval call binding the contract method 0x890c283b.
+//
+// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) pure returns(address)
+func (_VmSafe *VmSafeCallerSession) ComputeCreate2Address(salt [32]byte, initCodeHash [32]byte) (common.Address, error) {
+	return _VmSafe.Contract.ComputeCreate2Address(&_VmSafe.CallOpts, salt, initCodeHash)
+}
+
+// ComputeCreate2Address0 is a free data retrieval call binding the contract method 0xd323826a.
+//
+// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) pure returns(address)
+func (_VmSafe *VmSafeCaller) ComputeCreate2Address0(opts *bind.CallOpts, salt [32]byte, initCodeHash [32]byte, deployer common.Address) (common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "computeCreate2Address0", salt, initCodeHash, deployer)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// ComputeCreate2Address0 is a free data retrieval call binding the contract method 0xd323826a.
+//
+// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) pure returns(address)
+func (_VmSafe *VmSafeSession) ComputeCreate2Address0(salt [32]byte, initCodeHash [32]byte, deployer common.Address) (common.Address, error) {
+	return _VmSafe.Contract.ComputeCreate2Address0(&_VmSafe.CallOpts, salt, initCodeHash, deployer)
+}
+
+// ComputeCreate2Address0 is a free data retrieval call binding the contract method 0xd323826a.
+//
+// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) pure returns(address)
+func (_VmSafe *VmSafeCallerSession) ComputeCreate2Address0(salt [32]byte, initCodeHash [32]byte, deployer common.Address) (common.Address, error) {
+	return _VmSafe.Contract.ComputeCreate2Address0(&_VmSafe.CallOpts, salt, initCodeHash, deployer)
+}
+
+// ComputeCreateAddress is a free data retrieval call binding the contract method 0x74637a7a.
+//
+// Solidity: function computeCreateAddress(address deployer, uint256 nonce) pure returns(address)
+func (_VmSafe *VmSafeCaller) ComputeCreateAddress(opts *bind.CallOpts, deployer common.Address, nonce *big.Int) (common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "computeCreateAddress", deployer, nonce)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// ComputeCreateAddress is a free data retrieval call binding the contract method 0x74637a7a.
+//
+// Solidity: function computeCreateAddress(address deployer, uint256 nonce) pure returns(address)
+func (_VmSafe *VmSafeSession) ComputeCreateAddress(deployer common.Address, nonce *big.Int) (common.Address, error) {
+	return _VmSafe.Contract.ComputeCreateAddress(&_VmSafe.CallOpts, deployer, nonce)
+}
+
+// ComputeCreateAddress is a free data retrieval call binding the contract method 0x74637a7a.
+//
+// Solidity: function computeCreateAddress(address deployer, uint256 nonce) pure returns(address)
+func (_VmSafe *VmSafeCallerSession) ComputeCreateAddress(deployer common.Address, nonce *big.Int) (common.Address, error) {
+	return _VmSafe.Contract.ComputeCreateAddress(&_VmSafe.CallOpts, deployer, nonce)
+}
+
+// DeriveKey is a free data retrieval call binding the contract method 0x29233b1f.
+//
+// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index, string language) pure returns(uint256 privateKey)
+func (_VmSafe *VmSafeCaller) DeriveKey(opts *bind.CallOpts, mnemonic string, derivationPath string, index uint32, language string) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "deriveKey", mnemonic, derivationPath, index, language)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// DeriveKey is a free data retrieval call binding the contract method 0x29233b1f.
+//
+// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index, string language) pure returns(uint256 privateKey)
+func (_VmSafe *VmSafeSession) DeriveKey(mnemonic string, derivationPath string, index uint32, language string) (*big.Int, error) {
+	return _VmSafe.Contract.DeriveKey(&_VmSafe.CallOpts, mnemonic, derivationPath, index, language)
+}
+
+// DeriveKey is a free data retrieval call binding the contract method 0x29233b1f.
+//
+// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index, string language) pure returns(uint256 privateKey)
+func (_VmSafe *VmSafeCallerSession) DeriveKey(mnemonic string, derivationPath string, index uint32, language string) (*big.Int, error) {
+	return _VmSafe.Contract.DeriveKey(&_VmSafe.CallOpts, mnemonic, derivationPath, index, language)
+}
+
+// DeriveKey0 is a free data retrieval call binding the contract method 0x32c8176d.
+//
+// Solidity: function deriveKey(string mnemonic, uint32 index, string language) pure returns(uint256 privateKey)
+func (_VmSafe *VmSafeCaller) DeriveKey0(opts *bind.CallOpts, mnemonic string, index uint32, language string) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "deriveKey0", mnemonic, index, language)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// DeriveKey0 is a free data retrieval call binding the contract method 0x32c8176d.
+//
+// Solidity: function deriveKey(string mnemonic, uint32 index, string language) pure returns(uint256 privateKey)
+func (_VmSafe *VmSafeSession) DeriveKey0(mnemonic string, index uint32, language string) (*big.Int, error) {
+	return _VmSafe.Contract.DeriveKey0(&_VmSafe.CallOpts, mnemonic, index, language)
+}
+
+// DeriveKey0 is a free data retrieval call binding the contract method 0x32c8176d.
+//
+// Solidity: function deriveKey(string mnemonic, uint32 index, string language) pure returns(uint256 privateKey)
+func (_VmSafe *VmSafeCallerSession) DeriveKey0(mnemonic string, index uint32, language string) (*big.Int, error) {
+	return _VmSafe.Contract.DeriveKey0(&_VmSafe.CallOpts, mnemonic, index, language)
+}
+
+// DeriveKey1 is a free data retrieval call binding the contract method 0x6229498b.
+//
+// Solidity: function deriveKey(string mnemonic, uint32 index) pure returns(uint256 privateKey)
+func (_VmSafe *VmSafeCaller) DeriveKey1(opts *bind.CallOpts, mnemonic string, index uint32) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "deriveKey1", mnemonic, index)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// DeriveKey1 is a free data retrieval call binding the contract method 0x6229498b.
+//
+// Solidity: function deriveKey(string mnemonic, uint32 index) pure returns(uint256 privateKey)
+func (_VmSafe *VmSafeSession) DeriveKey1(mnemonic string, index uint32) (*big.Int, error) {
+	return _VmSafe.Contract.DeriveKey1(&_VmSafe.CallOpts, mnemonic, index)
+}
+
+// DeriveKey1 is a free data retrieval call binding the contract method 0x6229498b.
+//
+// Solidity: function deriveKey(string mnemonic, uint32 index) pure returns(uint256 privateKey)
+func (_VmSafe *VmSafeCallerSession) DeriveKey1(mnemonic string, index uint32) (*big.Int, error) {
+	return _VmSafe.Contract.DeriveKey1(&_VmSafe.CallOpts, mnemonic, index)
+}
+
+// DeriveKey2 is a free data retrieval call binding the contract method 0x6bcb2c1b.
+//
+// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index) pure returns(uint256 privateKey)
+func (_VmSafe *VmSafeCaller) DeriveKey2(opts *bind.CallOpts, mnemonic string, derivationPath string, index uint32) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "deriveKey2", mnemonic, derivationPath, index)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// DeriveKey2 is a free data retrieval call binding the contract method 0x6bcb2c1b.
+//
+// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index) pure returns(uint256 privateKey)
+func (_VmSafe *VmSafeSession) DeriveKey2(mnemonic string, derivationPath string, index uint32) (*big.Int, error) {
+	return _VmSafe.Contract.DeriveKey2(&_VmSafe.CallOpts, mnemonic, derivationPath, index)
+}
+
+// DeriveKey2 is a free data retrieval call binding the contract method 0x6bcb2c1b.
+//
+// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index) pure returns(uint256 privateKey)
+func (_VmSafe *VmSafeCallerSession) DeriveKey2(mnemonic string, derivationPath string, index uint32) (*big.Int, error) {
+	return _VmSafe.Contract.DeriveKey2(&_VmSafe.CallOpts, mnemonic, derivationPath, index)
+}
+
+// EnsNamehash is a free data retrieval call binding the contract method 0x8c374c65.
+//
+// Solidity: function ensNamehash(string name) pure returns(bytes32)
+func (_VmSafe *VmSafeCaller) EnsNamehash(opts *bind.CallOpts, name string) ([32]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "ensNamehash", name)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// EnsNamehash is a free data retrieval call binding the contract method 0x8c374c65.
+//
+// Solidity: function ensNamehash(string name) pure returns(bytes32)
+func (_VmSafe *VmSafeSession) EnsNamehash(name string) ([32]byte, error) {
+	return _VmSafe.Contract.EnsNamehash(&_VmSafe.CallOpts, name)
+}
+
+// EnsNamehash is a free data retrieval call binding the contract method 0x8c374c65.
+//
+// Solidity: function ensNamehash(string name) pure returns(bytes32)
+func (_VmSafe *VmSafeCallerSession) EnsNamehash(name string) ([32]byte, error) {
+	return _VmSafe.Contract.EnsNamehash(&_VmSafe.CallOpts, name)
+}
+
+// EnvAddress is a free data retrieval call binding the contract method 0x350d56bf.
+//
+// Solidity: function envAddress(string name) view returns(address value)
+func (_VmSafe *VmSafeCaller) EnvAddress(opts *bind.CallOpts, name string) (common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envAddress", name)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// EnvAddress is a free data retrieval call binding the contract method 0x350d56bf.
+//
+// Solidity: function envAddress(string name) view returns(address value)
+func (_VmSafe *VmSafeSession) EnvAddress(name string) (common.Address, error) {
+	return _VmSafe.Contract.EnvAddress(&_VmSafe.CallOpts, name)
+}
+
+// EnvAddress is a free data retrieval call binding the contract method 0x350d56bf.
+//
+// Solidity: function envAddress(string name) view returns(address value)
+func (_VmSafe *VmSafeCallerSession) EnvAddress(name string) (common.Address, error) {
+	return _VmSafe.Contract.EnvAddress(&_VmSafe.CallOpts, name)
+}
+
+// EnvAddress0 is a free data retrieval call binding the contract method 0xad31b9fa.
+//
+// Solidity: function envAddress(string name, string delim) view returns(address[] value)
+func (_VmSafe *VmSafeCaller) EnvAddress0(opts *bind.CallOpts, name string, delim string) ([]common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envAddress0", name, delim)
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// EnvAddress0 is a free data retrieval call binding the contract method 0xad31b9fa.
+//
+// Solidity: function envAddress(string name, string delim) view returns(address[] value)
+func (_VmSafe *VmSafeSession) EnvAddress0(name string, delim string) ([]common.Address, error) {
+	return _VmSafe.Contract.EnvAddress0(&_VmSafe.CallOpts, name, delim)
+}
+
+// EnvAddress0 is a free data retrieval call binding the contract method 0xad31b9fa.
+//
+// Solidity: function envAddress(string name, string delim) view returns(address[] value)
+func (_VmSafe *VmSafeCallerSession) EnvAddress0(name string, delim string) ([]common.Address, error) {
+	return _VmSafe.Contract.EnvAddress0(&_VmSafe.CallOpts, name, delim)
+}
+
+// EnvBool is a free data retrieval call binding the contract method 0x7ed1ec7d.
+//
+// Solidity: function envBool(string name) view returns(bool value)
+func (_VmSafe *VmSafeCaller) EnvBool(opts *bind.CallOpts, name string) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envBool", name)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// EnvBool is a free data retrieval call binding the contract method 0x7ed1ec7d.
+//
+// Solidity: function envBool(string name) view returns(bool value)
+func (_VmSafe *VmSafeSession) EnvBool(name string) (bool, error) {
+	return _VmSafe.Contract.EnvBool(&_VmSafe.CallOpts, name)
+}
+
+// EnvBool is a free data retrieval call binding the contract method 0x7ed1ec7d.
+//
+// Solidity: function envBool(string name) view returns(bool value)
+func (_VmSafe *VmSafeCallerSession) EnvBool(name string) (bool, error) {
+	return _VmSafe.Contract.EnvBool(&_VmSafe.CallOpts, name)
+}
+
+// EnvBool0 is a free data retrieval call binding the contract method 0xaaaddeaf.
+//
+// Solidity: function envBool(string name, string delim) view returns(bool[] value)
+func (_VmSafe *VmSafeCaller) EnvBool0(opts *bind.CallOpts, name string, delim string) ([]bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envBool0", name, delim)
+
+	if err != nil {
+		return *new([]bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool)
+
+	return out0, err
+
+}
+
+// EnvBool0 is a free data retrieval call binding the contract method 0xaaaddeaf.
+//
+// Solidity: function envBool(string name, string delim) view returns(bool[] value)
+func (_VmSafe *VmSafeSession) EnvBool0(name string, delim string) ([]bool, error) {
+	return _VmSafe.Contract.EnvBool0(&_VmSafe.CallOpts, name, delim)
+}
+
+// EnvBool0 is a free data retrieval call binding the contract method 0xaaaddeaf.
+//
+// Solidity: function envBool(string name, string delim) view returns(bool[] value)
+func (_VmSafe *VmSafeCallerSession) EnvBool0(name string, delim string) ([]bool, error) {
+	return _VmSafe.Contract.EnvBool0(&_VmSafe.CallOpts, name, delim)
+}
+
+// EnvBytes is a free data retrieval call binding the contract method 0x4d7baf06.
+//
+// Solidity: function envBytes(string name) view returns(bytes value)
+func (_VmSafe *VmSafeCaller) EnvBytes(opts *bind.CallOpts, name string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envBytes", name)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// EnvBytes is a free data retrieval call binding the contract method 0x4d7baf06.
+//
+// Solidity: function envBytes(string name) view returns(bytes value)
+func (_VmSafe *VmSafeSession) EnvBytes(name string) ([]byte, error) {
+	return _VmSafe.Contract.EnvBytes(&_VmSafe.CallOpts, name)
+}
+
+// EnvBytes is a free data retrieval call binding the contract method 0x4d7baf06.
+//
+// Solidity: function envBytes(string name) view returns(bytes value)
+func (_VmSafe *VmSafeCallerSession) EnvBytes(name string) ([]byte, error) {
+	return _VmSafe.Contract.EnvBytes(&_VmSafe.CallOpts, name)
+}
+
+// EnvBytes0 is a free data retrieval call binding the contract method 0xddc2651b.
+//
+// Solidity: function envBytes(string name, string delim) view returns(bytes[] value)
+func (_VmSafe *VmSafeCaller) EnvBytes0(opts *bind.CallOpts, name string, delim string) ([][]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envBytes0", name, delim)
+
+	if err != nil {
+		return *new([][]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte)
+
+	return out0, err
+
+}
+
+// EnvBytes0 is a free data retrieval call binding the contract method 0xddc2651b.
+//
+// Solidity: function envBytes(string name, string delim) view returns(bytes[] value)
+func (_VmSafe *VmSafeSession) EnvBytes0(name string, delim string) ([][]byte, error) {
+	return _VmSafe.Contract.EnvBytes0(&_VmSafe.CallOpts, name, delim)
+}
+
+// EnvBytes0 is a free data retrieval call binding the contract method 0xddc2651b.
+//
+// Solidity: function envBytes(string name, string delim) view returns(bytes[] value)
+func (_VmSafe *VmSafeCallerSession) EnvBytes0(name string, delim string) ([][]byte, error) {
+	return _VmSafe.Contract.EnvBytes0(&_VmSafe.CallOpts, name, delim)
+}
+
+// EnvBytes32 is a free data retrieval call binding the contract method 0x5af231c1.
+//
+// Solidity: function envBytes32(string name, string delim) view returns(bytes32[] value)
+func (_VmSafe *VmSafeCaller) EnvBytes32(opts *bind.CallOpts, name string, delim string) ([][32]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envBytes32", name, delim)
+
+	if err != nil {
+		return *new([][32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte)
+
+	return out0, err
+
+}
+
+// EnvBytes32 is a free data retrieval call binding the contract method 0x5af231c1.
+//
+// Solidity: function envBytes32(string name, string delim) view returns(bytes32[] value)
+func (_VmSafe *VmSafeSession) EnvBytes32(name string, delim string) ([][32]byte, error) {
+	return _VmSafe.Contract.EnvBytes32(&_VmSafe.CallOpts, name, delim)
+}
+
+// EnvBytes32 is a free data retrieval call binding the contract method 0x5af231c1.
+//
+// Solidity: function envBytes32(string name, string delim) view returns(bytes32[] value)
+func (_VmSafe *VmSafeCallerSession) EnvBytes32(name string, delim string) ([][32]byte, error) {
+	return _VmSafe.Contract.EnvBytes32(&_VmSafe.CallOpts, name, delim)
+}
+
+// EnvBytes320 is a free data retrieval call binding the contract method 0x97949042.
+//
+// Solidity: function envBytes32(string name) view returns(bytes32 value)
+func (_VmSafe *VmSafeCaller) EnvBytes320(opts *bind.CallOpts, name string) ([32]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envBytes320", name)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// EnvBytes320 is a free data retrieval call binding the contract method 0x97949042.
+//
+// Solidity: function envBytes32(string name) view returns(bytes32 value)
+func (_VmSafe *VmSafeSession) EnvBytes320(name string) ([32]byte, error) {
+	return _VmSafe.Contract.EnvBytes320(&_VmSafe.CallOpts, name)
+}
+
+// EnvBytes320 is a free data retrieval call binding the contract method 0x97949042.
+//
+// Solidity: function envBytes32(string name) view returns(bytes32 value)
+func (_VmSafe *VmSafeCallerSession) EnvBytes320(name string) ([32]byte, error) {
+	return _VmSafe.Contract.EnvBytes320(&_VmSafe.CallOpts, name)
+}
+
+// EnvExists is a free data retrieval call binding the contract method 0xce8365f9.
+//
+// Solidity: function envExists(string name) view returns(bool result)
+func (_VmSafe *VmSafeCaller) EnvExists(opts *bind.CallOpts, name string) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envExists", name)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// EnvExists is a free data retrieval call binding the contract method 0xce8365f9.
+//
+// Solidity: function envExists(string name) view returns(bool result)
+func (_VmSafe *VmSafeSession) EnvExists(name string) (bool, error) {
+	return _VmSafe.Contract.EnvExists(&_VmSafe.CallOpts, name)
+}
+
+// EnvExists is a free data retrieval call binding the contract method 0xce8365f9.
+//
+// Solidity: function envExists(string name) view returns(bool result)
+func (_VmSafe *VmSafeCallerSession) EnvExists(name string) (bool, error) {
+	return _VmSafe.Contract.EnvExists(&_VmSafe.CallOpts, name)
+}
+
+// EnvInt is a free data retrieval call binding the contract method 0x42181150.
+//
+// Solidity: function envInt(string name, string delim) view returns(int256[] value)
+func (_VmSafe *VmSafeCaller) EnvInt(opts *bind.CallOpts, name string, delim string) ([]*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envInt", name, delim)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// EnvInt is a free data retrieval call binding the contract method 0x42181150.
+//
+// Solidity: function envInt(string name, string delim) view returns(int256[] value)
+func (_VmSafe *VmSafeSession) EnvInt(name string, delim string) ([]*big.Int, error) {
+	return _VmSafe.Contract.EnvInt(&_VmSafe.CallOpts, name, delim)
+}
+
+// EnvInt is a free data retrieval call binding the contract method 0x42181150.
+//
+// Solidity: function envInt(string name, string delim) view returns(int256[] value)
+func (_VmSafe *VmSafeCallerSession) EnvInt(name string, delim string) ([]*big.Int, error) {
+	return _VmSafe.Contract.EnvInt(&_VmSafe.CallOpts, name, delim)
+}
+
+// EnvInt0 is a free data retrieval call binding the contract method 0x892a0c61.
+//
+// Solidity: function envInt(string name) view returns(int256 value)
+func (_VmSafe *VmSafeCaller) EnvInt0(opts *bind.CallOpts, name string) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envInt0", name)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// EnvInt0 is a free data retrieval call binding the contract method 0x892a0c61.
+//
+// Solidity: function envInt(string name) view returns(int256 value)
+func (_VmSafe *VmSafeSession) EnvInt0(name string) (*big.Int, error) {
+	return _VmSafe.Contract.EnvInt0(&_VmSafe.CallOpts, name)
+}
+
+// EnvInt0 is a free data retrieval call binding the contract method 0x892a0c61.
+//
+// Solidity: function envInt(string name) view returns(int256 value)
+func (_VmSafe *VmSafeCallerSession) EnvInt0(name string) (*big.Int, error) {
+	return _VmSafe.Contract.EnvInt0(&_VmSafe.CallOpts, name)
+}
+
+// EnvOr is a free data retrieval call binding the contract method 0x2281f367.
+//
+// Solidity: function envOr(string name, string delim, bytes32[] defaultValue) view returns(bytes32[] value)
+func (_VmSafe *VmSafeCaller) EnvOr(opts *bind.CallOpts, name string, delim string, defaultValue [][32]byte) ([][32]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([][32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte)
+
+	return out0, err
+
+}
+
+// EnvOr is a free data retrieval call binding the contract method 0x2281f367.
+//
+// Solidity: function envOr(string name, string delim, bytes32[] defaultValue) view returns(bytes32[] value)
+func (_VmSafe *VmSafeSession) EnvOr(name string, delim string, defaultValue [][32]byte) ([][32]byte, error) {
+	return _VmSafe.Contract.EnvOr(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr is a free data retrieval call binding the contract method 0x2281f367.
+//
+// Solidity: function envOr(string name, string delim, bytes32[] defaultValue) view returns(bytes32[] value)
+func (_VmSafe *VmSafeCallerSession) EnvOr(name string, delim string, defaultValue [][32]byte) ([][32]byte, error) {
+	return _VmSafe.Contract.EnvOr(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr0 is a free data retrieval call binding the contract method 0x4700d74b.
+//
+// Solidity: function envOr(string name, string delim, int256[] defaultValue) view returns(int256[] value)
+func (_VmSafe *VmSafeCaller) EnvOr0(opts *bind.CallOpts, name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr0", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// EnvOr0 is a free data retrieval call binding the contract method 0x4700d74b.
+//
+// Solidity: function envOr(string name, string delim, int256[] defaultValue) view returns(int256[] value)
+func (_VmSafe *VmSafeSession) EnvOr0(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) {
+	return _VmSafe.Contract.EnvOr0(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr0 is a free data retrieval call binding the contract method 0x4700d74b.
+//
+// Solidity: function envOr(string name, string delim, int256[] defaultValue) view returns(int256[] value)
+func (_VmSafe *VmSafeCallerSession) EnvOr0(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) {
+	return _VmSafe.Contract.EnvOr0(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr1 is a free data retrieval call binding the contract method 0x4777f3cf.
+//
+// Solidity: function envOr(string name, bool defaultValue) view returns(bool value)
+func (_VmSafe *VmSafeCaller) EnvOr1(opts *bind.CallOpts, name string, defaultValue bool) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr1", name, defaultValue)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// EnvOr1 is a free data retrieval call binding the contract method 0x4777f3cf.
+//
+// Solidity: function envOr(string name, bool defaultValue) view returns(bool value)
+func (_VmSafe *VmSafeSession) EnvOr1(name string, defaultValue bool) (bool, error) {
+	return _VmSafe.Contract.EnvOr1(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvOr1 is a free data retrieval call binding the contract method 0x4777f3cf.
+//
+// Solidity: function envOr(string name, bool defaultValue) view returns(bool value)
+func (_VmSafe *VmSafeCallerSession) EnvOr1(name string, defaultValue bool) (bool, error) {
+	return _VmSafe.Contract.EnvOr1(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvOr10 is a free data retrieval call binding the contract method 0xc74e9deb.
+//
+// Solidity: function envOr(string name, string delim, address[] defaultValue) view returns(address[] value)
+func (_VmSafe *VmSafeCaller) EnvOr10(opts *bind.CallOpts, name string, delim string, defaultValue []common.Address) ([]common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr10", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// EnvOr10 is a free data retrieval call binding the contract method 0xc74e9deb.
+//
+// Solidity: function envOr(string name, string delim, address[] defaultValue) view returns(address[] value)
+func (_VmSafe *VmSafeSession) EnvOr10(name string, delim string, defaultValue []common.Address) ([]common.Address, error) {
+	return _VmSafe.Contract.EnvOr10(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr10 is a free data retrieval call binding the contract method 0xc74e9deb.
+//
+// Solidity: function envOr(string name, string delim, address[] defaultValue) view returns(address[] value)
+func (_VmSafe *VmSafeCallerSession) EnvOr10(name string, delim string, defaultValue []common.Address) ([]common.Address, error) {
+	return _VmSafe.Contract.EnvOr10(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr11 is a free data retrieval call binding the contract method 0xd145736c.
+//
+// Solidity: function envOr(string name, string defaultValue) view returns(string value)
+func (_VmSafe *VmSafeCaller) EnvOr11(opts *bind.CallOpts, name string, defaultValue string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr11", name, defaultValue)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// EnvOr11 is a free data retrieval call binding the contract method 0xd145736c.
+//
+// Solidity: function envOr(string name, string defaultValue) view returns(string value)
+func (_VmSafe *VmSafeSession) EnvOr11(name string, defaultValue string) (string, error) {
+	return _VmSafe.Contract.EnvOr11(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvOr11 is a free data retrieval call binding the contract method 0xd145736c.
+//
+// Solidity: function envOr(string name, string defaultValue) view returns(string value)
+func (_VmSafe *VmSafeCallerSession) EnvOr11(name string, defaultValue string) (string, error) {
+	return _VmSafe.Contract.EnvOr11(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvOr12 is a free data retrieval call binding the contract method 0xeb85e83b.
+//
+// Solidity: function envOr(string name, string delim, bool[] defaultValue) view returns(bool[] value)
+func (_VmSafe *VmSafeCaller) EnvOr12(opts *bind.CallOpts, name string, delim string, defaultValue []bool) ([]bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr12", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([]bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool)
+
+	return out0, err
+
+}
+
+// EnvOr12 is a free data retrieval call binding the contract method 0xeb85e83b.
+//
+// Solidity: function envOr(string name, string delim, bool[] defaultValue) view returns(bool[] value)
+func (_VmSafe *VmSafeSession) EnvOr12(name string, delim string, defaultValue []bool) ([]bool, error) {
+	return _VmSafe.Contract.EnvOr12(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr12 is a free data retrieval call binding the contract method 0xeb85e83b.
+//
+// Solidity: function envOr(string name, string delim, bool[] defaultValue) view returns(bool[] value)
+func (_VmSafe *VmSafeCallerSession) EnvOr12(name string, delim string, defaultValue []bool) ([]bool, error) {
+	return _VmSafe.Contract.EnvOr12(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr2 is a free data retrieval call binding the contract method 0x561fe540.
+//
+// Solidity: function envOr(string name, address defaultValue) view returns(address value)
+func (_VmSafe *VmSafeCaller) EnvOr2(opts *bind.CallOpts, name string, defaultValue common.Address) (common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr2", name, defaultValue)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// EnvOr2 is a free data retrieval call binding the contract method 0x561fe540.
+//
+// Solidity: function envOr(string name, address defaultValue) view returns(address value)
+func (_VmSafe *VmSafeSession) EnvOr2(name string, defaultValue common.Address) (common.Address, error) {
+	return _VmSafe.Contract.EnvOr2(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvOr2 is a free data retrieval call binding the contract method 0x561fe540.
+//
+// Solidity: function envOr(string name, address defaultValue) view returns(address value)
+func (_VmSafe *VmSafeCallerSession) EnvOr2(name string, defaultValue common.Address) (common.Address, error) {
+	return _VmSafe.Contract.EnvOr2(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvOr3 is a free data retrieval call binding the contract method 0x5e97348f.
+//
+// Solidity: function envOr(string name, uint256 defaultValue) view returns(uint256 value)
+func (_VmSafe *VmSafeCaller) EnvOr3(opts *bind.CallOpts, name string, defaultValue *big.Int) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr3", name, defaultValue)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// EnvOr3 is a free data retrieval call binding the contract method 0x5e97348f.
+//
+// Solidity: function envOr(string name, uint256 defaultValue) view returns(uint256 value)
+func (_VmSafe *VmSafeSession) EnvOr3(name string, defaultValue *big.Int) (*big.Int, error) {
+	return _VmSafe.Contract.EnvOr3(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvOr3 is a free data retrieval call binding the contract method 0x5e97348f.
+//
+// Solidity: function envOr(string name, uint256 defaultValue) view returns(uint256 value)
+func (_VmSafe *VmSafeCallerSession) EnvOr3(name string, defaultValue *big.Int) (*big.Int, error) {
+	return _VmSafe.Contract.EnvOr3(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvOr4 is a free data retrieval call binding the contract method 0x64bc3e64.
+//
+// Solidity: function envOr(string name, string delim, bytes[] defaultValue) view returns(bytes[] value)
+func (_VmSafe *VmSafeCaller) EnvOr4(opts *bind.CallOpts, name string, delim string, defaultValue [][]byte) ([][]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr4", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([][]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte)
+
+	return out0, err
+
+}
+
+// EnvOr4 is a free data retrieval call binding the contract method 0x64bc3e64.
+//
+// Solidity: function envOr(string name, string delim, bytes[] defaultValue) view returns(bytes[] value)
+func (_VmSafe *VmSafeSession) EnvOr4(name string, delim string, defaultValue [][]byte) ([][]byte, error) {
+	return _VmSafe.Contract.EnvOr4(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr4 is a free data retrieval call binding the contract method 0x64bc3e64.
+//
+// Solidity: function envOr(string name, string delim, bytes[] defaultValue) view returns(bytes[] value)
+func (_VmSafe *VmSafeCallerSession) EnvOr4(name string, delim string, defaultValue [][]byte) ([][]byte, error) {
+	return _VmSafe.Contract.EnvOr4(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr5 is a free data retrieval call binding the contract method 0x74318528.
+//
+// Solidity: function envOr(string name, string delim, uint256[] defaultValue) view returns(uint256[] value)
+func (_VmSafe *VmSafeCaller) EnvOr5(opts *bind.CallOpts, name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr5", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// EnvOr5 is a free data retrieval call binding the contract method 0x74318528.
+//
+// Solidity: function envOr(string name, string delim, uint256[] defaultValue) view returns(uint256[] value)
+func (_VmSafe *VmSafeSession) EnvOr5(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) {
+	return _VmSafe.Contract.EnvOr5(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr5 is a free data retrieval call binding the contract method 0x74318528.
+//
+// Solidity: function envOr(string name, string delim, uint256[] defaultValue) view returns(uint256[] value)
+func (_VmSafe *VmSafeCallerSession) EnvOr5(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) {
+	return _VmSafe.Contract.EnvOr5(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr6 is a free data retrieval call binding the contract method 0x859216bc.
+//
+// Solidity: function envOr(string name, string delim, string[] defaultValue) view returns(string[] value)
+func (_VmSafe *VmSafeCaller) EnvOr6(opts *bind.CallOpts, name string, delim string, defaultValue []string) ([]string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr6", name, delim, defaultValue)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// EnvOr6 is a free data retrieval call binding the contract method 0x859216bc.
+//
+// Solidity: function envOr(string name, string delim, string[] defaultValue) view returns(string[] value)
+func (_VmSafe *VmSafeSession) EnvOr6(name string, delim string, defaultValue []string) ([]string, error) {
+	return _VmSafe.Contract.EnvOr6(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr6 is a free data retrieval call binding the contract method 0x859216bc.
+//
+// Solidity: function envOr(string name, string delim, string[] defaultValue) view returns(string[] value)
+func (_VmSafe *VmSafeCallerSession) EnvOr6(name string, delim string, defaultValue []string) ([]string, error) {
+	return _VmSafe.Contract.EnvOr6(&_VmSafe.CallOpts, name, delim, defaultValue)
+}
+
+// EnvOr7 is a free data retrieval call binding the contract method 0xb3e47705.
+//
+// Solidity: function envOr(string name, bytes defaultValue) view returns(bytes value)
+func (_VmSafe *VmSafeCaller) EnvOr7(opts *bind.CallOpts, name string, defaultValue []byte) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr7", name, defaultValue)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// EnvOr7 is a free data retrieval call binding the contract method 0xb3e47705.
+//
+// Solidity: function envOr(string name, bytes defaultValue) view returns(bytes value)
+func (_VmSafe *VmSafeSession) EnvOr7(name string, defaultValue []byte) ([]byte, error) {
+	return _VmSafe.Contract.EnvOr7(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvOr7 is a free data retrieval call binding the contract method 0xb3e47705.
+//
+// Solidity: function envOr(string name, bytes defaultValue) view returns(bytes value)
+func (_VmSafe *VmSafeCallerSession) EnvOr7(name string, defaultValue []byte) ([]byte, error) {
+	return _VmSafe.Contract.EnvOr7(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvOr8 is a free data retrieval call binding the contract method 0xb4a85892.
+//
+// Solidity: function envOr(string name, bytes32 defaultValue) view returns(bytes32 value)
+func (_VmSafe *VmSafeCaller) EnvOr8(opts *bind.CallOpts, name string, defaultValue [32]byte) ([32]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr8", name, defaultValue)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// EnvOr8 is a free data retrieval call binding the contract method 0xb4a85892.
+//
+// Solidity: function envOr(string name, bytes32 defaultValue) view returns(bytes32 value)
+func (_VmSafe *VmSafeSession) EnvOr8(name string, defaultValue [32]byte) ([32]byte, error) {
+	return _VmSafe.Contract.EnvOr8(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvOr8 is a free data retrieval call binding the contract method 0xb4a85892.
+//
+// Solidity: function envOr(string name, bytes32 defaultValue) view returns(bytes32 value)
+func (_VmSafe *VmSafeCallerSession) EnvOr8(name string, defaultValue [32]byte) ([32]byte, error) {
+	return _VmSafe.Contract.EnvOr8(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvOr9 is a free data retrieval call binding the contract method 0xbbcb713e.
+//
+// Solidity: function envOr(string name, int256 defaultValue) view returns(int256 value)
+func (_VmSafe *VmSafeCaller) EnvOr9(opts *bind.CallOpts, name string, defaultValue *big.Int) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envOr9", name, defaultValue)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// EnvOr9 is a free data retrieval call binding the contract method 0xbbcb713e.
+//
+// Solidity: function envOr(string name, int256 defaultValue) view returns(int256 value)
+func (_VmSafe *VmSafeSession) EnvOr9(name string, defaultValue *big.Int) (*big.Int, error) {
+	return _VmSafe.Contract.EnvOr9(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvOr9 is a free data retrieval call binding the contract method 0xbbcb713e.
+//
+// Solidity: function envOr(string name, int256 defaultValue) view returns(int256 value)
+func (_VmSafe *VmSafeCallerSession) EnvOr9(name string, defaultValue *big.Int) (*big.Int, error) {
+	return _VmSafe.Contract.EnvOr9(&_VmSafe.CallOpts, name, defaultValue)
+}
+
+// EnvString is a free data retrieval call binding the contract method 0x14b02bc9.
+//
+// Solidity: function envString(string name, string delim) view returns(string[] value)
+func (_VmSafe *VmSafeCaller) EnvString(opts *bind.CallOpts, name string, delim string) ([]string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envString", name, delim)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// EnvString is a free data retrieval call binding the contract method 0x14b02bc9.
+//
+// Solidity: function envString(string name, string delim) view returns(string[] value)
+func (_VmSafe *VmSafeSession) EnvString(name string, delim string) ([]string, error) {
+	return _VmSafe.Contract.EnvString(&_VmSafe.CallOpts, name, delim)
+}
+
+// EnvString is a free data retrieval call binding the contract method 0x14b02bc9.
+//
+// Solidity: function envString(string name, string delim) view returns(string[] value)
+func (_VmSafe *VmSafeCallerSession) EnvString(name string, delim string) ([]string, error) {
+	return _VmSafe.Contract.EnvString(&_VmSafe.CallOpts, name, delim)
+}
+
+// EnvString0 is a free data retrieval call binding the contract method 0xf877cb19.
+//
+// Solidity: function envString(string name) view returns(string value)
+func (_VmSafe *VmSafeCaller) EnvString0(opts *bind.CallOpts, name string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envString0", name)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// EnvString0 is a free data retrieval call binding the contract method 0xf877cb19.
+//
+// Solidity: function envString(string name) view returns(string value)
+func (_VmSafe *VmSafeSession) EnvString0(name string) (string, error) {
+	return _VmSafe.Contract.EnvString0(&_VmSafe.CallOpts, name)
+}
+
+// EnvString0 is a free data retrieval call binding the contract method 0xf877cb19.
+//
+// Solidity: function envString(string name) view returns(string value)
+func (_VmSafe *VmSafeCallerSession) EnvString0(name string) (string, error) {
+	return _VmSafe.Contract.EnvString0(&_VmSafe.CallOpts, name)
+}
+
+// EnvUint is a free data retrieval call binding the contract method 0xc1978d1f.
+//
+// Solidity: function envUint(string name) view returns(uint256 value)
+func (_VmSafe *VmSafeCaller) EnvUint(opts *bind.CallOpts, name string) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envUint", name)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// EnvUint is a free data retrieval call binding the contract method 0xc1978d1f.
+//
+// Solidity: function envUint(string name) view returns(uint256 value)
+func (_VmSafe *VmSafeSession) EnvUint(name string) (*big.Int, error) {
+	return _VmSafe.Contract.EnvUint(&_VmSafe.CallOpts, name)
+}
+
+// EnvUint is a free data retrieval call binding the contract method 0xc1978d1f.
+//
+// Solidity: function envUint(string name) view returns(uint256 value)
+func (_VmSafe *VmSafeCallerSession) EnvUint(name string) (*big.Int, error) {
+	return _VmSafe.Contract.EnvUint(&_VmSafe.CallOpts, name)
+}
+
+// EnvUint0 is a free data retrieval call binding the contract method 0xf3dec099.
+//
+// Solidity: function envUint(string name, string delim) view returns(uint256[] value)
+func (_VmSafe *VmSafeCaller) EnvUint0(opts *bind.CallOpts, name string, delim string) ([]*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "envUint0", name, delim)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// EnvUint0 is a free data retrieval call binding the contract method 0xf3dec099.
+//
+// Solidity: function envUint(string name, string delim) view returns(uint256[] value)
+func (_VmSafe *VmSafeSession) EnvUint0(name string, delim string) ([]*big.Int, error) {
+	return _VmSafe.Contract.EnvUint0(&_VmSafe.CallOpts, name, delim)
+}
+
+// EnvUint0 is a free data retrieval call binding the contract method 0xf3dec099.
+//
+// Solidity: function envUint(string name, string delim) view returns(uint256[] value)
+func (_VmSafe *VmSafeCallerSession) EnvUint0(name string, delim string) ([]*big.Int, error) {
+	return _VmSafe.Contract.EnvUint0(&_VmSafe.CallOpts, name, delim)
+}
+
+// Exists is a free data retrieval call binding the contract method 0x261a323e.
+//
+// Solidity: function exists(string path) view returns(bool result)
+func (_VmSafe *VmSafeCaller) Exists(opts *bind.CallOpts, path string) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "exists", path)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// Exists is a free data retrieval call binding the contract method 0x261a323e.
+//
+// Solidity: function exists(string path) view returns(bool result)
+func (_VmSafe *VmSafeSession) Exists(path string) (bool, error) {
+	return _VmSafe.Contract.Exists(&_VmSafe.CallOpts, path)
+}
+
+// Exists is a free data retrieval call binding the contract method 0x261a323e.
+//
+// Solidity: function exists(string path) view returns(bool result)
+func (_VmSafe *VmSafeCallerSession) Exists(path string) (bool, error) {
+	return _VmSafe.Contract.Exists(&_VmSafe.CallOpts, path)
+}
+
+// FoundryVersionAtLeast is a free data retrieval call binding the contract method 0x6248be1f.
+//
+// Solidity: function foundryVersionAtLeast(string version) view returns(bool)
+func (_VmSafe *VmSafeCaller) FoundryVersionAtLeast(opts *bind.CallOpts, version string) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "foundryVersionAtLeast", version)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// FoundryVersionAtLeast is a free data retrieval call binding the contract method 0x6248be1f.
+//
+// Solidity: function foundryVersionAtLeast(string version) view returns(bool)
+func (_VmSafe *VmSafeSession) FoundryVersionAtLeast(version string) (bool, error) {
+	return _VmSafe.Contract.FoundryVersionAtLeast(&_VmSafe.CallOpts, version)
+}
+
+// FoundryVersionAtLeast is a free data retrieval call binding the contract method 0x6248be1f.
+//
+// Solidity: function foundryVersionAtLeast(string version) view returns(bool)
+func (_VmSafe *VmSafeCallerSession) FoundryVersionAtLeast(version string) (bool, error) {
+	return _VmSafe.Contract.FoundryVersionAtLeast(&_VmSafe.CallOpts, version)
+}
+
+// FoundryVersionCmp is a free data retrieval call binding the contract method 0xca7b0a09.
+//
+// Solidity: function foundryVersionCmp(string version) view returns(int256)
+func (_VmSafe *VmSafeCaller) FoundryVersionCmp(opts *bind.CallOpts, version string) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "foundryVersionCmp", version)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// FoundryVersionCmp is a free data retrieval call binding the contract method 0xca7b0a09.
+//
+// Solidity: function foundryVersionCmp(string version) view returns(int256)
+func (_VmSafe *VmSafeSession) FoundryVersionCmp(version string) (*big.Int, error) {
+	return _VmSafe.Contract.FoundryVersionCmp(&_VmSafe.CallOpts, version)
+}
+
+// FoundryVersionCmp is a free data retrieval call binding the contract method 0xca7b0a09.
+//
+// Solidity: function foundryVersionCmp(string version) view returns(int256)
+func (_VmSafe *VmSafeCallerSession) FoundryVersionCmp(version string) (*big.Int, error) {
+	return _VmSafe.Contract.FoundryVersionCmp(&_VmSafe.CallOpts, version)
+}
+
+// FsMetadata is a free data retrieval call binding the contract method 0xaf368a08.
+//
+// Solidity: function fsMetadata(string path) view returns((bool,bool,uint256,bool,uint256,uint256,uint256) metadata)
+func (_VmSafe *VmSafeCaller) FsMetadata(opts *bind.CallOpts, path string) (VmSafeFsMetadata, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "fsMetadata", path)
+
+	if err != nil {
+		return *new(VmSafeFsMetadata), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(VmSafeFsMetadata)).(*VmSafeFsMetadata)
+
+	return out0, err
+
+}
+
+// FsMetadata is a free data retrieval call binding the contract method 0xaf368a08.
+//
+// Solidity: function fsMetadata(string path) view returns((bool,bool,uint256,bool,uint256,uint256,uint256) metadata)
+func (_VmSafe *VmSafeSession) FsMetadata(path string) (VmSafeFsMetadata, error) {
+	return _VmSafe.Contract.FsMetadata(&_VmSafe.CallOpts, path)
+}
+
+// FsMetadata is a free data retrieval call binding the contract method 0xaf368a08.
+//
+// Solidity: function fsMetadata(string path) view returns((bool,bool,uint256,bool,uint256,uint256,uint256) metadata)
+func (_VmSafe *VmSafeCallerSession) FsMetadata(path string) (VmSafeFsMetadata, error) {
+	return _VmSafe.Contract.FsMetadata(&_VmSafe.CallOpts, path)
+}
+
+// GetArtifactPathByCode is a free data retrieval call binding the contract method 0xeb74848c.
+//
+// Solidity: function getArtifactPathByCode(bytes code) view returns(string path)
+func (_VmSafe *VmSafeCaller) GetArtifactPathByCode(opts *bind.CallOpts, code []byte) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getArtifactPathByCode", code)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetArtifactPathByCode is a free data retrieval call binding the contract method 0xeb74848c.
+//
+// Solidity: function getArtifactPathByCode(bytes code) view returns(string path)
+func (_VmSafe *VmSafeSession) GetArtifactPathByCode(code []byte) (string, error) {
+	return _VmSafe.Contract.GetArtifactPathByCode(&_VmSafe.CallOpts, code)
+}
+
+// GetArtifactPathByCode is a free data retrieval call binding the contract method 0xeb74848c.
+//
+// Solidity: function getArtifactPathByCode(bytes code) view returns(string path)
+func (_VmSafe *VmSafeCallerSession) GetArtifactPathByCode(code []byte) (string, error) {
+	return _VmSafe.Contract.GetArtifactPathByCode(&_VmSafe.CallOpts, code)
+}
+
+// GetArtifactPathByDeployedCode is a free data retrieval call binding the contract method 0x6d853ba5.
+//
+// Solidity: function getArtifactPathByDeployedCode(bytes deployedCode) view returns(string path)
+func (_VmSafe *VmSafeCaller) GetArtifactPathByDeployedCode(opts *bind.CallOpts, deployedCode []byte) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getArtifactPathByDeployedCode", deployedCode)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetArtifactPathByDeployedCode is a free data retrieval call binding the contract method 0x6d853ba5.
+//
+// Solidity: function getArtifactPathByDeployedCode(bytes deployedCode) view returns(string path)
+func (_VmSafe *VmSafeSession) GetArtifactPathByDeployedCode(deployedCode []byte) (string, error) {
+	return _VmSafe.Contract.GetArtifactPathByDeployedCode(&_VmSafe.CallOpts, deployedCode)
+}
+
+// GetArtifactPathByDeployedCode is a free data retrieval call binding the contract method 0x6d853ba5.
+//
+// Solidity: function getArtifactPathByDeployedCode(bytes deployedCode) view returns(string path)
+func (_VmSafe *VmSafeCallerSession) GetArtifactPathByDeployedCode(deployedCode []byte) (string, error) {
+	return _VmSafe.Contract.GetArtifactPathByDeployedCode(&_VmSafe.CallOpts, deployedCode)
+}
+
+// GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7.
+//
+// Solidity: function getBlobBaseFee() view returns(uint256 blobBaseFee)
+func (_VmSafe *VmSafeCaller) GetBlobBaseFee(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getBlobBaseFee")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7.
+//
+// Solidity: function getBlobBaseFee() view returns(uint256 blobBaseFee)
+func (_VmSafe *VmSafeSession) GetBlobBaseFee() (*big.Int, error) {
+	return _VmSafe.Contract.GetBlobBaseFee(&_VmSafe.CallOpts)
+}
+
+// GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7.
+//
+// Solidity: function getBlobBaseFee() view returns(uint256 blobBaseFee)
+func (_VmSafe *VmSafeCallerSession) GetBlobBaseFee() (*big.Int, error) {
+	return _VmSafe.Contract.GetBlobBaseFee(&_VmSafe.CallOpts)
+}
+
+// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c.
+//
+// Solidity: function getBlockNumber() view returns(uint256 height)
+func (_VmSafe *VmSafeCaller) GetBlockNumber(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getBlockNumber")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c.
+//
+// Solidity: function getBlockNumber() view returns(uint256 height)
+func (_VmSafe *VmSafeSession) GetBlockNumber() (*big.Int, error) {
+	return _VmSafe.Contract.GetBlockNumber(&_VmSafe.CallOpts)
+}
+
+// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c.
+//
+// Solidity: function getBlockNumber() view returns(uint256 height)
+func (_VmSafe *VmSafeCallerSession) GetBlockNumber() (*big.Int, error) {
+	return _VmSafe.Contract.GetBlockNumber(&_VmSafe.CallOpts)
+}
+
+// GetBlockTimestamp is a free data retrieval call binding the contract method 0x796b89b9.
+//
+// Solidity: function getBlockTimestamp() view returns(uint256 timestamp)
+func (_VmSafe *VmSafeCaller) GetBlockTimestamp(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getBlockTimestamp")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetBlockTimestamp is a free data retrieval call binding the contract method 0x796b89b9.
+//
+// Solidity: function getBlockTimestamp() view returns(uint256 timestamp)
+func (_VmSafe *VmSafeSession) GetBlockTimestamp() (*big.Int, error) {
+	return _VmSafe.Contract.GetBlockTimestamp(&_VmSafe.CallOpts)
+}
+
+// GetBlockTimestamp is a free data retrieval call binding the contract method 0x796b89b9.
+//
+// Solidity: function getBlockTimestamp() view returns(uint256 timestamp)
+func (_VmSafe *VmSafeCallerSession) GetBlockTimestamp() (*big.Int, error) {
+	return _VmSafe.Contract.GetBlockTimestamp(&_VmSafe.CallOpts)
+}
+
+// GetBroadcast is a free data retrieval call binding the contract method 0x3dc90cb3.
+//
+// Solidity: function getBroadcast(string contractName, uint64 chainId, uint8 txType) view returns((bytes32,uint8,address,uint64,bool))
+func (_VmSafe *VmSafeCaller) GetBroadcast(opts *bind.CallOpts, contractName string, chainId uint64, txType uint8) (VmSafeBroadcastTxSummary, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getBroadcast", contractName, chainId, txType)
+
+	if err != nil {
+		return *new(VmSafeBroadcastTxSummary), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(VmSafeBroadcastTxSummary)).(*VmSafeBroadcastTxSummary)
+
+	return out0, err
+
+}
+
+// GetBroadcast is a free data retrieval call binding the contract method 0x3dc90cb3.
+//
+// Solidity: function getBroadcast(string contractName, uint64 chainId, uint8 txType) view returns((bytes32,uint8,address,uint64,bool))
+func (_VmSafe *VmSafeSession) GetBroadcast(contractName string, chainId uint64, txType uint8) (VmSafeBroadcastTxSummary, error) {
+	return _VmSafe.Contract.GetBroadcast(&_VmSafe.CallOpts, contractName, chainId, txType)
+}
+
+// GetBroadcast is a free data retrieval call binding the contract method 0x3dc90cb3.
+//
+// Solidity: function getBroadcast(string contractName, uint64 chainId, uint8 txType) view returns((bytes32,uint8,address,uint64,bool))
+func (_VmSafe *VmSafeCallerSession) GetBroadcast(contractName string, chainId uint64, txType uint8) (VmSafeBroadcastTxSummary, error) {
+	return _VmSafe.Contract.GetBroadcast(&_VmSafe.CallOpts, contractName, chainId, txType)
+}
+
+// GetBroadcasts is a free data retrieval call binding the contract method 0xf2fa4a26.
+//
+// Solidity: function getBroadcasts(string contractName, uint64 chainId) view returns((bytes32,uint8,address,uint64,bool)[])
+func (_VmSafe *VmSafeCaller) GetBroadcasts(opts *bind.CallOpts, contractName string, chainId uint64) ([]VmSafeBroadcastTxSummary, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getBroadcasts", contractName, chainId)
+
+	if err != nil {
+		return *new([]VmSafeBroadcastTxSummary), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]VmSafeBroadcastTxSummary)).(*[]VmSafeBroadcastTxSummary)
+
+	return out0, err
+
+}
+
+// GetBroadcasts is a free data retrieval call binding the contract method 0xf2fa4a26.
+//
+// Solidity: function getBroadcasts(string contractName, uint64 chainId) view returns((bytes32,uint8,address,uint64,bool)[])
+func (_VmSafe *VmSafeSession) GetBroadcasts(contractName string, chainId uint64) ([]VmSafeBroadcastTxSummary, error) {
+	return _VmSafe.Contract.GetBroadcasts(&_VmSafe.CallOpts, contractName, chainId)
+}
+
+// GetBroadcasts is a free data retrieval call binding the contract method 0xf2fa4a26.
+//
+// Solidity: function getBroadcasts(string contractName, uint64 chainId) view returns((bytes32,uint8,address,uint64,bool)[])
+func (_VmSafe *VmSafeCallerSession) GetBroadcasts(contractName string, chainId uint64) ([]VmSafeBroadcastTxSummary, error) {
+	return _VmSafe.Contract.GetBroadcasts(&_VmSafe.CallOpts, contractName, chainId)
+}
+
+// GetBroadcasts0 is a free data retrieval call binding the contract method 0xf7afe919.
+//
+// Solidity: function getBroadcasts(string contractName, uint64 chainId, uint8 txType) view returns((bytes32,uint8,address,uint64,bool)[])
+func (_VmSafe *VmSafeCaller) GetBroadcasts0(opts *bind.CallOpts, contractName string, chainId uint64, txType uint8) ([]VmSafeBroadcastTxSummary, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getBroadcasts0", contractName, chainId, txType)
+
+	if err != nil {
+		return *new([]VmSafeBroadcastTxSummary), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]VmSafeBroadcastTxSummary)).(*[]VmSafeBroadcastTxSummary)
+
+	return out0, err
+
+}
+
+// GetBroadcasts0 is a free data retrieval call binding the contract method 0xf7afe919.
+//
+// Solidity: function getBroadcasts(string contractName, uint64 chainId, uint8 txType) view returns((bytes32,uint8,address,uint64,bool)[])
+func (_VmSafe *VmSafeSession) GetBroadcasts0(contractName string, chainId uint64, txType uint8) ([]VmSafeBroadcastTxSummary, error) {
+	return _VmSafe.Contract.GetBroadcasts0(&_VmSafe.CallOpts, contractName, chainId, txType)
+}
+
+// GetBroadcasts0 is a free data retrieval call binding the contract method 0xf7afe919.
+//
+// Solidity: function getBroadcasts(string contractName, uint64 chainId, uint8 txType) view returns((bytes32,uint8,address,uint64,bool)[])
+func (_VmSafe *VmSafeCallerSession) GetBroadcasts0(contractName string, chainId uint64, txType uint8) ([]VmSafeBroadcastTxSummary, error) {
+	return _VmSafe.Contract.GetBroadcasts0(&_VmSafe.CallOpts, contractName, chainId, txType)
+}
+
+// GetCode is a free data retrieval call binding the contract method 0x8d1cc925.
+//
+// Solidity: function getCode(string artifactPath) view returns(bytes creationBytecode)
+func (_VmSafe *VmSafeCaller) GetCode(opts *bind.CallOpts, artifactPath string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getCode", artifactPath)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// GetCode is a free data retrieval call binding the contract method 0x8d1cc925.
+//
+// Solidity: function getCode(string artifactPath) view returns(bytes creationBytecode)
+func (_VmSafe *VmSafeSession) GetCode(artifactPath string) ([]byte, error) {
+	return _VmSafe.Contract.GetCode(&_VmSafe.CallOpts, artifactPath)
+}
+
+// GetCode is a free data retrieval call binding the contract method 0x8d1cc925.
+//
+// Solidity: function getCode(string artifactPath) view returns(bytes creationBytecode)
+func (_VmSafe *VmSafeCallerSession) GetCode(artifactPath string) ([]byte, error) {
+	return _VmSafe.Contract.GetCode(&_VmSafe.CallOpts, artifactPath)
+}
+
+// GetDeployedCode is a free data retrieval call binding the contract method 0x3ebf73b4.
+//
+// Solidity: function getDeployedCode(string artifactPath) view returns(bytes runtimeBytecode)
+func (_VmSafe *VmSafeCaller) GetDeployedCode(opts *bind.CallOpts, artifactPath string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getDeployedCode", artifactPath)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// GetDeployedCode is a free data retrieval call binding the contract method 0x3ebf73b4.
+//
+// Solidity: function getDeployedCode(string artifactPath) view returns(bytes runtimeBytecode)
+func (_VmSafe *VmSafeSession) GetDeployedCode(artifactPath string) ([]byte, error) {
+	return _VmSafe.Contract.GetDeployedCode(&_VmSafe.CallOpts, artifactPath)
+}
+
+// GetDeployedCode is a free data retrieval call binding the contract method 0x3ebf73b4.
+//
+// Solidity: function getDeployedCode(string artifactPath) view returns(bytes runtimeBytecode)
+func (_VmSafe *VmSafeCallerSession) GetDeployedCode(artifactPath string) ([]byte, error) {
+	return _VmSafe.Contract.GetDeployedCode(&_VmSafe.CallOpts, artifactPath)
+}
+
+// GetDeployment is a free data retrieval call binding the contract method 0x0debd5d6.
+//
+// Solidity: function getDeployment(string contractName, uint64 chainId) view returns(address deployedAddress)
+func (_VmSafe *VmSafeCaller) GetDeployment(opts *bind.CallOpts, contractName string, chainId uint64) (common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getDeployment", contractName, chainId)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// GetDeployment is a free data retrieval call binding the contract method 0x0debd5d6.
+//
+// Solidity: function getDeployment(string contractName, uint64 chainId) view returns(address deployedAddress)
+func (_VmSafe *VmSafeSession) GetDeployment(contractName string, chainId uint64) (common.Address, error) {
+	return _VmSafe.Contract.GetDeployment(&_VmSafe.CallOpts, contractName, chainId)
+}
+
+// GetDeployment is a free data retrieval call binding the contract method 0x0debd5d6.
+//
+// Solidity: function getDeployment(string contractName, uint64 chainId) view returns(address deployedAddress)
+func (_VmSafe *VmSafeCallerSession) GetDeployment(contractName string, chainId uint64) (common.Address, error) {
+	return _VmSafe.Contract.GetDeployment(&_VmSafe.CallOpts, contractName, chainId)
+}
+
+// GetDeployment0 is a free data retrieval call binding the contract method 0xa8091d97.
+//
+// Solidity: function getDeployment(string contractName) view returns(address deployedAddress)
+func (_VmSafe *VmSafeCaller) GetDeployment0(opts *bind.CallOpts, contractName string) (common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getDeployment0", contractName)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// GetDeployment0 is a free data retrieval call binding the contract method 0xa8091d97.
+//
+// Solidity: function getDeployment(string contractName) view returns(address deployedAddress)
+func (_VmSafe *VmSafeSession) GetDeployment0(contractName string) (common.Address, error) {
+	return _VmSafe.Contract.GetDeployment0(&_VmSafe.CallOpts, contractName)
+}
+
+// GetDeployment0 is a free data retrieval call binding the contract method 0xa8091d97.
+//
+// Solidity: function getDeployment(string contractName) view returns(address deployedAddress)
+func (_VmSafe *VmSafeCallerSession) GetDeployment0(contractName string) (common.Address, error) {
+	return _VmSafe.Contract.GetDeployment0(&_VmSafe.CallOpts, contractName)
+}
+
+// GetDeployments is a free data retrieval call binding the contract method 0x74e133dd.
+//
+// Solidity: function getDeployments(string contractName, uint64 chainId) view returns(address[] deployedAddresses)
+func (_VmSafe *VmSafeCaller) GetDeployments(opts *bind.CallOpts, contractName string, chainId uint64) ([]common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getDeployments", contractName, chainId)
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// GetDeployments is a free data retrieval call binding the contract method 0x74e133dd.
+//
+// Solidity: function getDeployments(string contractName, uint64 chainId) view returns(address[] deployedAddresses)
+func (_VmSafe *VmSafeSession) GetDeployments(contractName string, chainId uint64) ([]common.Address, error) {
+	return _VmSafe.Contract.GetDeployments(&_VmSafe.CallOpts, contractName, chainId)
+}
+
+// GetDeployments is a free data retrieval call binding the contract method 0x74e133dd.
+//
+// Solidity: function getDeployments(string contractName, uint64 chainId) view returns(address[] deployedAddresses)
+func (_VmSafe *VmSafeCallerSession) GetDeployments(contractName string, chainId uint64) ([]common.Address, error) {
+	return _VmSafe.Contract.GetDeployments(&_VmSafe.CallOpts, contractName, chainId)
+}
+
+// GetFoundryVersion is a free data retrieval call binding the contract method 0xea991bb5.
+//
+// Solidity: function getFoundryVersion() view returns(string version)
+func (_VmSafe *VmSafeCaller) GetFoundryVersion(opts *bind.CallOpts) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getFoundryVersion")
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetFoundryVersion is a free data retrieval call binding the contract method 0xea991bb5.
+//
+// Solidity: function getFoundryVersion() view returns(string version)
+func (_VmSafe *VmSafeSession) GetFoundryVersion() (string, error) {
+	return _VmSafe.Contract.GetFoundryVersion(&_VmSafe.CallOpts)
+}
+
+// GetFoundryVersion is a free data retrieval call binding the contract method 0xea991bb5.
+//
+// Solidity: function getFoundryVersion() view returns(string version)
+func (_VmSafe *VmSafeCallerSession) GetFoundryVersion() (string, error) {
+	return _VmSafe.Contract.GetFoundryVersion(&_VmSafe.CallOpts)
+}
+
+// GetLabel is a free data retrieval call binding the contract method 0x28a249b0.
+//
+// Solidity: function getLabel(address account) view returns(string currentLabel)
+func (_VmSafe *VmSafeCaller) GetLabel(opts *bind.CallOpts, account common.Address) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getLabel", account)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetLabel is a free data retrieval call binding the contract method 0x28a249b0.
+//
+// Solidity: function getLabel(address account) view returns(string currentLabel)
+func (_VmSafe *VmSafeSession) GetLabel(account common.Address) (string, error) {
+	return _VmSafe.Contract.GetLabel(&_VmSafe.CallOpts, account)
+}
+
+// GetLabel is a free data retrieval call binding the contract method 0x28a249b0.
+//
+// Solidity: function getLabel(address account) view returns(string currentLabel)
+func (_VmSafe *VmSafeCallerSession) GetLabel(account common.Address) (string, error) {
+	return _VmSafe.Contract.GetLabel(&_VmSafe.CallOpts, account)
+}
+
+// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab.
+//
+// Solidity: function getNonce(address account) view returns(uint64 nonce)
+func (_VmSafe *VmSafeCaller) GetNonce(opts *bind.CallOpts, account common.Address) (uint64, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getNonce", account)
+
+	if err != nil {
+		return *new(uint64), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64)
+
+	return out0, err
+
+}
+
+// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab.
+//
+// Solidity: function getNonce(address account) view returns(uint64 nonce)
+func (_VmSafe *VmSafeSession) GetNonce(account common.Address) (uint64, error) {
+	return _VmSafe.Contract.GetNonce(&_VmSafe.CallOpts, account)
+}
+
+// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab.
+//
+// Solidity: function getNonce(address account) view returns(uint64 nonce)
+func (_VmSafe *VmSafeCallerSession) GetNonce(account common.Address) (uint64, error) {
+	return _VmSafe.Contract.GetNonce(&_VmSafe.CallOpts, account)
+}
+
+// GetStateDiff is a free data retrieval call binding the contract method 0x80df01cc.
+//
+// Solidity: function getStateDiff() view returns(string diff)
+func (_VmSafe *VmSafeCaller) GetStateDiff(opts *bind.CallOpts) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getStateDiff")
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetStateDiff is a free data retrieval call binding the contract method 0x80df01cc.
+//
+// Solidity: function getStateDiff() view returns(string diff)
+func (_VmSafe *VmSafeSession) GetStateDiff() (string, error) {
+	return _VmSafe.Contract.GetStateDiff(&_VmSafe.CallOpts)
+}
+
+// GetStateDiff is a free data retrieval call binding the contract method 0x80df01cc.
+//
+// Solidity: function getStateDiff() view returns(string diff)
+func (_VmSafe *VmSafeCallerSession) GetStateDiff() (string, error) {
+	return _VmSafe.Contract.GetStateDiff(&_VmSafe.CallOpts)
+}
+
+// GetStateDiffJson is a free data retrieval call binding the contract method 0xf54fe009.
+//
+// Solidity: function getStateDiffJson() view returns(string diff)
+func (_VmSafe *VmSafeCaller) GetStateDiffJson(opts *bind.CallOpts) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "getStateDiffJson")
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetStateDiffJson is a free data retrieval call binding the contract method 0xf54fe009.
+//
+// Solidity: function getStateDiffJson() view returns(string diff)
+func (_VmSafe *VmSafeSession) GetStateDiffJson() (string, error) {
+	return _VmSafe.Contract.GetStateDiffJson(&_VmSafe.CallOpts)
+}
+
+// GetStateDiffJson is a free data retrieval call binding the contract method 0xf54fe009.
+//
+// Solidity: function getStateDiffJson() view returns(string diff)
+func (_VmSafe *VmSafeCallerSession) GetStateDiffJson() (string, error) {
+	return _VmSafe.Contract.GetStateDiffJson(&_VmSafe.CallOpts)
+}
+
+// IndexOf is a free data retrieval call binding the contract method 0x8a0807b7.
+//
+// Solidity: function indexOf(string input, string key) pure returns(uint256)
+func (_VmSafe *VmSafeCaller) IndexOf(opts *bind.CallOpts, input string, key string) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "indexOf", input, key)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// IndexOf is a free data retrieval call binding the contract method 0x8a0807b7.
+//
+// Solidity: function indexOf(string input, string key) pure returns(uint256)
+func (_VmSafe *VmSafeSession) IndexOf(input string, key string) (*big.Int, error) {
+	return _VmSafe.Contract.IndexOf(&_VmSafe.CallOpts, input, key)
+}
+
+// IndexOf is a free data retrieval call binding the contract method 0x8a0807b7.
+//
+// Solidity: function indexOf(string input, string key) pure returns(uint256)
+func (_VmSafe *VmSafeCallerSession) IndexOf(input string, key string) (*big.Int, error) {
+	return _VmSafe.Contract.IndexOf(&_VmSafe.CallOpts, input, key)
+}
+
+// IsContext is a free data retrieval call binding the contract method 0x64af255d.
+//
+// Solidity: function isContext(uint8 context) view returns(bool result)
+func (_VmSafe *VmSafeCaller) IsContext(opts *bind.CallOpts, context uint8) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "isContext", context)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// IsContext is a free data retrieval call binding the contract method 0x64af255d.
+//
+// Solidity: function isContext(uint8 context) view returns(bool result)
+func (_VmSafe *VmSafeSession) IsContext(context uint8) (bool, error) {
+	return _VmSafe.Contract.IsContext(&_VmSafe.CallOpts, context)
+}
+
+// IsContext is a free data retrieval call binding the contract method 0x64af255d.
+//
+// Solidity: function isContext(uint8 context) view returns(bool result)
+func (_VmSafe *VmSafeCallerSession) IsContext(context uint8) (bool, error) {
+	return _VmSafe.Contract.IsContext(&_VmSafe.CallOpts, context)
+}
+
+// IsDir is a free data retrieval call binding the contract method 0x7d15d019.
+//
+// Solidity: function isDir(string path) view returns(bool result)
+func (_VmSafe *VmSafeCaller) IsDir(opts *bind.CallOpts, path string) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "isDir", path)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// IsDir is a free data retrieval call binding the contract method 0x7d15d019.
+//
+// Solidity: function isDir(string path) view returns(bool result)
+func (_VmSafe *VmSafeSession) IsDir(path string) (bool, error) {
+	return _VmSafe.Contract.IsDir(&_VmSafe.CallOpts, path)
+}
+
+// IsDir is a free data retrieval call binding the contract method 0x7d15d019.
+//
+// Solidity: function isDir(string path) view returns(bool result)
+func (_VmSafe *VmSafeCallerSession) IsDir(path string) (bool, error) {
+	return _VmSafe.Contract.IsDir(&_VmSafe.CallOpts, path)
+}
+
+// IsFile is a free data retrieval call binding the contract method 0xe0eb04d4.
+//
+// Solidity: function isFile(string path) view returns(bool result)
+func (_VmSafe *VmSafeCaller) IsFile(opts *bind.CallOpts, path string) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "isFile", path)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// IsFile is a free data retrieval call binding the contract method 0xe0eb04d4.
+//
+// Solidity: function isFile(string path) view returns(bool result)
+func (_VmSafe *VmSafeSession) IsFile(path string) (bool, error) {
+	return _VmSafe.Contract.IsFile(&_VmSafe.CallOpts, path)
+}
+
+// IsFile is a free data retrieval call binding the contract method 0xe0eb04d4.
+//
+// Solidity: function isFile(string path) view returns(bool result)
+func (_VmSafe *VmSafeCallerSession) IsFile(path string) (bool, error) {
+	return _VmSafe.Contract.IsFile(&_VmSafe.CallOpts, path)
+}
+
+// KeyExists is a free data retrieval call binding the contract method 0x528a683c.
+//
+// Solidity: function keyExists(string json, string key) view returns(bool)
+func (_VmSafe *VmSafeCaller) KeyExists(opts *bind.CallOpts, json string, key string) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "keyExists", json, key)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// KeyExists is a free data retrieval call binding the contract method 0x528a683c.
+//
+// Solidity: function keyExists(string json, string key) view returns(bool)
+func (_VmSafe *VmSafeSession) KeyExists(json string, key string) (bool, error) {
+	return _VmSafe.Contract.KeyExists(&_VmSafe.CallOpts, json, key)
+}
+
+// KeyExists is a free data retrieval call binding the contract method 0x528a683c.
+//
+// Solidity: function keyExists(string json, string key) view returns(bool)
+func (_VmSafe *VmSafeCallerSession) KeyExists(json string, key string) (bool, error) {
+	return _VmSafe.Contract.KeyExists(&_VmSafe.CallOpts, json, key)
+}
+
+// KeyExistsJson is a free data retrieval call binding the contract method 0xdb4235f6.
+//
+// Solidity: function keyExistsJson(string json, string key) view returns(bool)
+func (_VmSafe *VmSafeCaller) KeyExistsJson(opts *bind.CallOpts, json string, key string) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "keyExistsJson", json, key)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// KeyExistsJson is a free data retrieval call binding the contract method 0xdb4235f6.
+//
+// Solidity: function keyExistsJson(string json, string key) view returns(bool)
+func (_VmSafe *VmSafeSession) KeyExistsJson(json string, key string) (bool, error) {
+	return _VmSafe.Contract.KeyExistsJson(&_VmSafe.CallOpts, json, key)
+}
+
+// KeyExistsJson is a free data retrieval call binding the contract method 0xdb4235f6.
+//
+// Solidity: function keyExistsJson(string json, string key) view returns(bool)
+func (_VmSafe *VmSafeCallerSession) KeyExistsJson(json string, key string) (bool, error) {
+	return _VmSafe.Contract.KeyExistsJson(&_VmSafe.CallOpts, json, key)
+}
+
+// KeyExistsToml is a free data retrieval call binding the contract method 0x600903ad.
+//
+// Solidity: function keyExistsToml(string toml, string key) view returns(bool)
+func (_VmSafe *VmSafeCaller) KeyExistsToml(opts *bind.CallOpts, toml string, key string) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "keyExistsToml", toml, key)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// KeyExistsToml is a free data retrieval call binding the contract method 0x600903ad.
+//
+// Solidity: function keyExistsToml(string toml, string key) view returns(bool)
+func (_VmSafe *VmSafeSession) KeyExistsToml(toml string, key string) (bool, error) {
+	return _VmSafe.Contract.KeyExistsToml(&_VmSafe.CallOpts, toml, key)
+}
+
+// KeyExistsToml is a free data retrieval call binding the contract method 0x600903ad.
+//
+// Solidity: function keyExistsToml(string toml, string key) view returns(bool)
+func (_VmSafe *VmSafeCallerSession) KeyExistsToml(toml string, key string) (bool, error) {
+	return _VmSafe.Contract.KeyExistsToml(&_VmSafe.CallOpts, toml, key)
+}
+
+// LastCallGas is a free data retrieval call binding the contract method 0x2b589b28.
+//
+// Solidity: function lastCallGas() view returns((uint64,uint64,uint64,int64,uint64) gas)
+func (_VmSafe *VmSafeCaller) LastCallGas(opts *bind.CallOpts) (VmSafeGas, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "lastCallGas")
+
+	if err != nil {
+		return *new(VmSafeGas), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(VmSafeGas)).(*VmSafeGas)
+
+	return out0, err
+
+}
+
+// LastCallGas is a free data retrieval call binding the contract method 0x2b589b28.
+//
+// Solidity: function lastCallGas() view returns((uint64,uint64,uint64,int64,uint64) gas)
+func (_VmSafe *VmSafeSession) LastCallGas() (VmSafeGas, error) {
+	return _VmSafe.Contract.LastCallGas(&_VmSafe.CallOpts)
+}
+
+// LastCallGas is a free data retrieval call binding the contract method 0x2b589b28.
+//
+// Solidity: function lastCallGas() view returns((uint64,uint64,uint64,int64,uint64) gas)
+func (_VmSafe *VmSafeCallerSession) LastCallGas() (VmSafeGas, error) {
+	return _VmSafe.Contract.LastCallGas(&_VmSafe.CallOpts)
+}
+
+// Load is a free data retrieval call binding the contract method 0x667f9d70.
+//
+// Solidity: function load(address target, bytes32 slot) view returns(bytes32 data)
+func (_VmSafe *VmSafeCaller) Load(opts *bind.CallOpts, target common.Address, slot [32]byte) ([32]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "load", target, slot)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// Load is a free data retrieval call binding the contract method 0x667f9d70.
+//
+// Solidity: function load(address target, bytes32 slot) view returns(bytes32 data)
+func (_VmSafe *VmSafeSession) Load(target common.Address, slot [32]byte) ([32]byte, error) {
+	return _VmSafe.Contract.Load(&_VmSafe.CallOpts, target, slot)
+}
+
+// Load is a free data retrieval call binding the contract method 0x667f9d70.
+//
+// Solidity: function load(address target, bytes32 slot) view returns(bytes32 data)
+func (_VmSafe *VmSafeCallerSession) Load(target common.Address, slot [32]byte) ([32]byte, error) {
+	return _VmSafe.Contract.Load(&_VmSafe.CallOpts, target, slot)
+}
+
+// ParseAddress is a free data retrieval call binding the contract method 0xc6ce059d.
+//
+// Solidity: function parseAddress(string stringifiedValue) pure returns(address parsedValue)
+func (_VmSafe *VmSafeCaller) ParseAddress(opts *bind.CallOpts, stringifiedValue string) (common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseAddress", stringifiedValue)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// ParseAddress is a free data retrieval call binding the contract method 0xc6ce059d.
+//
+// Solidity: function parseAddress(string stringifiedValue) pure returns(address parsedValue)
+func (_VmSafe *VmSafeSession) ParseAddress(stringifiedValue string) (common.Address, error) {
+	return _VmSafe.Contract.ParseAddress(&_VmSafe.CallOpts, stringifiedValue)
+}
+
+// ParseAddress is a free data retrieval call binding the contract method 0xc6ce059d.
+//
+// Solidity: function parseAddress(string stringifiedValue) pure returns(address parsedValue)
+func (_VmSafe *VmSafeCallerSession) ParseAddress(stringifiedValue string) (common.Address, error) {
+	return _VmSafe.Contract.ParseAddress(&_VmSafe.CallOpts, stringifiedValue)
+}
+
+// ParseBool is a free data retrieval call binding the contract method 0x974ef924.
+//
+// Solidity: function parseBool(string stringifiedValue) pure returns(bool parsedValue)
+func (_VmSafe *VmSafeCaller) ParseBool(opts *bind.CallOpts, stringifiedValue string) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseBool", stringifiedValue)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// ParseBool is a free data retrieval call binding the contract method 0x974ef924.
+//
+// Solidity: function parseBool(string stringifiedValue) pure returns(bool parsedValue)
+func (_VmSafe *VmSafeSession) ParseBool(stringifiedValue string) (bool, error) {
+	return _VmSafe.Contract.ParseBool(&_VmSafe.CallOpts, stringifiedValue)
+}
+
+// ParseBool is a free data retrieval call binding the contract method 0x974ef924.
+//
+// Solidity: function parseBool(string stringifiedValue) pure returns(bool parsedValue)
+func (_VmSafe *VmSafeCallerSession) ParseBool(stringifiedValue string) (bool, error) {
+	return _VmSafe.Contract.ParseBool(&_VmSafe.CallOpts, stringifiedValue)
+}
+
+// ParseBytes is a free data retrieval call binding the contract method 0x8f5d232d.
+//
+// Solidity: function parseBytes(string stringifiedValue) pure returns(bytes parsedValue)
+func (_VmSafe *VmSafeCaller) ParseBytes(opts *bind.CallOpts, stringifiedValue string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseBytes", stringifiedValue)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseBytes is a free data retrieval call binding the contract method 0x8f5d232d.
+//
+// Solidity: function parseBytes(string stringifiedValue) pure returns(bytes parsedValue)
+func (_VmSafe *VmSafeSession) ParseBytes(stringifiedValue string) ([]byte, error) {
+	return _VmSafe.Contract.ParseBytes(&_VmSafe.CallOpts, stringifiedValue)
+}
+
+// ParseBytes is a free data retrieval call binding the contract method 0x8f5d232d.
+//
+// Solidity: function parseBytes(string stringifiedValue) pure returns(bytes parsedValue)
+func (_VmSafe *VmSafeCallerSession) ParseBytes(stringifiedValue string) ([]byte, error) {
+	return _VmSafe.Contract.ParseBytes(&_VmSafe.CallOpts, stringifiedValue)
+}
+
+// ParseBytes32 is a free data retrieval call binding the contract method 0x087e6e81.
+//
+// Solidity: function parseBytes32(string stringifiedValue) pure returns(bytes32 parsedValue)
+func (_VmSafe *VmSafeCaller) ParseBytes32(opts *bind.CallOpts, stringifiedValue string) ([32]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseBytes32", stringifiedValue)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// ParseBytes32 is a free data retrieval call binding the contract method 0x087e6e81.
+//
+// Solidity: function parseBytes32(string stringifiedValue) pure returns(bytes32 parsedValue)
+func (_VmSafe *VmSafeSession) ParseBytes32(stringifiedValue string) ([32]byte, error) {
+	return _VmSafe.Contract.ParseBytes32(&_VmSafe.CallOpts, stringifiedValue)
+}
+
+// ParseBytes32 is a free data retrieval call binding the contract method 0x087e6e81.
+//
+// Solidity: function parseBytes32(string stringifiedValue) pure returns(bytes32 parsedValue)
+func (_VmSafe *VmSafeCallerSession) ParseBytes32(stringifiedValue string) ([32]byte, error) {
+	return _VmSafe.Contract.ParseBytes32(&_VmSafe.CallOpts, stringifiedValue)
+}
+
+// ParseInt is a free data retrieval call binding the contract method 0x42346c5e.
+//
+// Solidity: function parseInt(string stringifiedValue) pure returns(int256 parsedValue)
+func (_VmSafe *VmSafeCaller) ParseInt(opts *bind.CallOpts, stringifiedValue string) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseInt", stringifiedValue)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ParseInt is a free data retrieval call binding the contract method 0x42346c5e.
+//
+// Solidity: function parseInt(string stringifiedValue) pure returns(int256 parsedValue)
+func (_VmSafe *VmSafeSession) ParseInt(stringifiedValue string) (*big.Int, error) {
+	return _VmSafe.Contract.ParseInt(&_VmSafe.CallOpts, stringifiedValue)
+}
+
+// ParseInt is a free data retrieval call binding the contract method 0x42346c5e.
+//
+// Solidity: function parseInt(string stringifiedValue) pure returns(int256 parsedValue)
+func (_VmSafe *VmSafeCallerSession) ParseInt(stringifiedValue string) (*big.Int, error) {
+	return _VmSafe.Contract.ParseInt(&_VmSafe.CallOpts, stringifiedValue)
+}
+
+// ParseJson is a free data retrieval call binding the contract method 0x6a82600a.
+//
+// Solidity: function parseJson(string json) pure returns(bytes abiEncodedData)
+func (_VmSafe *VmSafeCaller) ParseJson(opts *bind.CallOpts, json string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJson", json)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseJson is a free data retrieval call binding the contract method 0x6a82600a.
+//
+// Solidity: function parseJson(string json) pure returns(bytes abiEncodedData)
+func (_VmSafe *VmSafeSession) ParseJson(json string) ([]byte, error) {
+	return _VmSafe.Contract.ParseJson(&_VmSafe.CallOpts, json)
+}
+
+// ParseJson is a free data retrieval call binding the contract method 0x6a82600a.
+//
+// Solidity: function parseJson(string json) pure returns(bytes abiEncodedData)
+func (_VmSafe *VmSafeCallerSession) ParseJson(json string) ([]byte, error) {
+	return _VmSafe.Contract.ParseJson(&_VmSafe.CallOpts, json)
+}
+
+// ParseJson0 is a free data retrieval call binding the contract method 0x85940ef1.
+//
+// Solidity: function parseJson(string json, string key) pure returns(bytes abiEncodedData)
+func (_VmSafe *VmSafeCaller) ParseJson0(opts *bind.CallOpts, json string, key string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJson0", json, key)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseJson0 is a free data retrieval call binding the contract method 0x85940ef1.
+//
+// Solidity: function parseJson(string json, string key) pure returns(bytes abiEncodedData)
+func (_VmSafe *VmSafeSession) ParseJson0(json string, key string) ([]byte, error) {
+	return _VmSafe.Contract.ParseJson0(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJson0 is a free data retrieval call binding the contract method 0x85940ef1.
+//
+// Solidity: function parseJson(string json, string key) pure returns(bytes abiEncodedData)
+func (_VmSafe *VmSafeCallerSession) ParseJson0(json string, key string) ([]byte, error) {
+	return _VmSafe.Contract.ParseJson0(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonAddress is a free data retrieval call binding the contract method 0x1e19e657.
+//
+// Solidity: function parseJsonAddress(string json, string key) pure returns(address)
+func (_VmSafe *VmSafeCaller) ParseJsonAddress(opts *bind.CallOpts, json string, key string) (common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonAddress", json, key)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// ParseJsonAddress is a free data retrieval call binding the contract method 0x1e19e657.
+//
+// Solidity: function parseJsonAddress(string json, string key) pure returns(address)
+func (_VmSafe *VmSafeSession) ParseJsonAddress(json string, key string) (common.Address, error) {
+	return _VmSafe.Contract.ParseJsonAddress(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonAddress is a free data retrieval call binding the contract method 0x1e19e657.
+//
+// Solidity: function parseJsonAddress(string json, string key) pure returns(address)
+func (_VmSafe *VmSafeCallerSession) ParseJsonAddress(json string, key string) (common.Address, error) {
+	return _VmSafe.Contract.ParseJsonAddress(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonAddressArray is a free data retrieval call binding the contract method 0x2fce7883.
+//
+// Solidity: function parseJsonAddressArray(string json, string key) pure returns(address[])
+func (_VmSafe *VmSafeCaller) ParseJsonAddressArray(opts *bind.CallOpts, json string, key string) ([]common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonAddressArray", json, key)
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ParseJsonAddressArray is a free data retrieval call binding the contract method 0x2fce7883.
+//
+// Solidity: function parseJsonAddressArray(string json, string key) pure returns(address[])
+func (_VmSafe *VmSafeSession) ParseJsonAddressArray(json string, key string) ([]common.Address, error) {
+	return _VmSafe.Contract.ParseJsonAddressArray(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonAddressArray is a free data retrieval call binding the contract method 0x2fce7883.
+//
+// Solidity: function parseJsonAddressArray(string json, string key) pure returns(address[])
+func (_VmSafe *VmSafeCallerSession) ParseJsonAddressArray(json string, key string) ([]common.Address, error) {
+	return _VmSafe.Contract.ParseJsonAddressArray(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonBool is a free data retrieval call binding the contract method 0x9f86dc91.
+//
+// Solidity: function parseJsonBool(string json, string key) pure returns(bool)
+func (_VmSafe *VmSafeCaller) ParseJsonBool(opts *bind.CallOpts, json string, key string) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonBool", json, key)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// ParseJsonBool is a free data retrieval call binding the contract method 0x9f86dc91.
+//
+// Solidity: function parseJsonBool(string json, string key) pure returns(bool)
+func (_VmSafe *VmSafeSession) ParseJsonBool(json string, key string) (bool, error) {
+	return _VmSafe.Contract.ParseJsonBool(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonBool is a free data retrieval call binding the contract method 0x9f86dc91.
+//
+// Solidity: function parseJsonBool(string json, string key) pure returns(bool)
+func (_VmSafe *VmSafeCallerSession) ParseJsonBool(json string, key string) (bool, error) {
+	return _VmSafe.Contract.ParseJsonBool(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonBoolArray is a free data retrieval call binding the contract method 0x91f3b94f.
+//
+// Solidity: function parseJsonBoolArray(string json, string key) pure returns(bool[])
+func (_VmSafe *VmSafeCaller) ParseJsonBoolArray(opts *bind.CallOpts, json string, key string) ([]bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonBoolArray", json, key)
+
+	if err != nil {
+		return *new([]bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool)
+
+	return out0, err
+
+}
+
+// ParseJsonBoolArray is a free data retrieval call binding the contract method 0x91f3b94f.
+//
+// Solidity: function parseJsonBoolArray(string json, string key) pure returns(bool[])
+func (_VmSafe *VmSafeSession) ParseJsonBoolArray(json string, key string) ([]bool, error) {
+	return _VmSafe.Contract.ParseJsonBoolArray(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonBoolArray is a free data retrieval call binding the contract method 0x91f3b94f.
+//
+// Solidity: function parseJsonBoolArray(string json, string key) pure returns(bool[])
+func (_VmSafe *VmSafeCallerSession) ParseJsonBoolArray(json string, key string) ([]bool, error) {
+	return _VmSafe.Contract.ParseJsonBoolArray(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonBytes is a free data retrieval call binding the contract method 0xfd921be8.
+//
+// Solidity: function parseJsonBytes(string json, string key) pure returns(bytes)
+func (_VmSafe *VmSafeCaller) ParseJsonBytes(opts *bind.CallOpts, json string, key string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonBytes", json, key)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonBytes is a free data retrieval call binding the contract method 0xfd921be8.
+//
+// Solidity: function parseJsonBytes(string json, string key) pure returns(bytes)
+func (_VmSafe *VmSafeSession) ParseJsonBytes(json string, key string) ([]byte, error) {
+	return _VmSafe.Contract.ParseJsonBytes(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonBytes is a free data retrieval call binding the contract method 0xfd921be8.
+//
+// Solidity: function parseJsonBytes(string json, string key) pure returns(bytes)
+func (_VmSafe *VmSafeCallerSession) ParseJsonBytes(json string, key string) ([]byte, error) {
+	return _VmSafe.Contract.ParseJsonBytes(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonBytes32 is a free data retrieval call binding the contract method 0x1777e59d.
+//
+// Solidity: function parseJsonBytes32(string json, string key) pure returns(bytes32)
+func (_VmSafe *VmSafeCaller) ParseJsonBytes32(opts *bind.CallOpts, json string, key string) ([32]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonBytes32", json, key)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonBytes32 is a free data retrieval call binding the contract method 0x1777e59d.
+//
+// Solidity: function parseJsonBytes32(string json, string key) pure returns(bytes32)
+func (_VmSafe *VmSafeSession) ParseJsonBytes32(json string, key string) ([32]byte, error) {
+	return _VmSafe.Contract.ParseJsonBytes32(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonBytes32 is a free data retrieval call binding the contract method 0x1777e59d.
+//
+// Solidity: function parseJsonBytes32(string json, string key) pure returns(bytes32)
+func (_VmSafe *VmSafeCallerSession) ParseJsonBytes32(json string, key string) ([32]byte, error) {
+	return _VmSafe.Contract.ParseJsonBytes32(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonBytes32Array is a free data retrieval call binding the contract method 0x91c75bc3.
+//
+// Solidity: function parseJsonBytes32Array(string json, string key) pure returns(bytes32[])
+func (_VmSafe *VmSafeCaller) ParseJsonBytes32Array(opts *bind.CallOpts, json string, key string) ([][32]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonBytes32Array", json, key)
+
+	if err != nil {
+		return *new([][32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonBytes32Array is a free data retrieval call binding the contract method 0x91c75bc3.
+//
+// Solidity: function parseJsonBytes32Array(string json, string key) pure returns(bytes32[])
+func (_VmSafe *VmSafeSession) ParseJsonBytes32Array(json string, key string) ([][32]byte, error) {
+	return _VmSafe.Contract.ParseJsonBytes32Array(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonBytes32Array is a free data retrieval call binding the contract method 0x91c75bc3.
+//
+// Solidity: function parseJsonBytes32Array(string json, string key) pure returns(bytes32[])
+func (_VmSafe *VmSafeCallerSession) ParseJsonBytes32Array(json string, key string) ([][32]byte, error) {
+	return _VmSafe.Contract.ParseJsonBytes32Array(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonBytesArray is a free data retrieval call binding the contract method 0x6631aa99.
+//
+// Solidity: function parseJsonBytesArray(string json, string key) pure returns(bytes[])
+func (_VmSafe *VmSafeCaller) ParseJsonBytesArray(opts *bind.CallOpts, json string, key string) ([][]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonBytesArray", json, key)
+
+	if err != nil {
+		return *new([][]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonBytesArray is a free data retrieval call binding the contract method 0x6631aa99.
+//
+// Solidity: function parseJsonBytesArray(string json, string key) pure returns(bytes[])
+func (_VmSafe *VmSafeSession) ParseJsonBytesArray(json string, key string) ([][]byte, error) {
+	return _VmSafe.Contract.ParseJsonBytesArray(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonBytesArray is a free data retrieval call binding the contract method 0x6631aa99.
+//
+// Solidity: function parseJsonBytesArray(string json, string key) pure returns(bytes[])
+func (_VmSafe *VmSafeCallerSession) ParseJsonBytesArray(json string, key string) ([][]byte, error) {
+	return _VmSafe.Contract.ParseJsonBytesArray(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonInt is a free data retrieval call binding the contract method 0x7b048ccd.
+//
+// Solidity: function parseJsonInt(string json, string key) pure returns(int256)
+func (_VmSafe *VmSafeCaller) ParseJsonInt(opts *bind.CallOpts, json string, key string) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonInt", json, key)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ParseJsonInt is a free data retrieval call binding the contract method 0x7b048ccd.
+//
+// Solidity: function parseJsonInt(string json, string key) pure returns(int256)
+func (_VmSafe *VmSafeSession) ParseJsonInt(json string, key string) (*big.Int, error) {
+	return _VmSafe.Contract.ParseJsonInt(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonInt is a free data retrieval call binding the contract method 0x7b048ccd.
+//
+// Solidity: function parseJsonInt(string json, string key) pure returns(int256)
+func (_VmSafe *VmSafeCallerSession) ParseJsonInt(json string, key string) (*big.Int, error) {
+	return _VmSafe.Contract.ParseJsonInt(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonIntArray is a free data retrieval call binding the contract method 0x9983c28a.
+//
+// Solidity: function parseJsonIntArray(string json, string key) pure returns(int256[])
+func (_VmSafe *VmSafeCaller) ParseJsonIntArray(opts *bind.CallOpts, json string, key string) ([]*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonIntArray", json, key)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// ParseJsonIntArray is a free data retrieval call binding the contract method 0x9983c28a.
+//
+// Solidity: function parseJsonIntArray(string json, string key) pure returns(int256[])
+func (_VmSafe *VmSafeSession) ParseJsonIntArray(json string, key string) ([]*big.Int, error) {
+	return _VmSafe.Contract.ParseJsonIntArray(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonIntArray is a free data retrieval call binding the contract method 0x9983c28a.
+//
+// Solidity: function parseJsonIntArray(string json, string key) pure returns(int256[])
+func (_VmSafe *VmSafeCallerSession) ParseJsonIntArray(json string, key string) ([]*big.Int, error) {
+	return _VmSafe.Contract.ParseJsonIntArray(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonKeys is a free data retrieval call binding the contract method 0x213e4198.
+//
+// Solidity: function parseJsonKeys(string json, string key) pure returns(string[] keys)
+func (_VmSafe *VmSafeCaller) ParseJsonKeys(opts *bind.CallOpts, json string, key string) ([]string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonKeys", json, key)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ParseJsonKeys is a free data retrieval call binding the contract method 0x213e4198.
+//
+// Solidity: function parseJsonKeys(string json, string key) pure returns(string[] keys)
+func (_VmSafe *VmSafeSession) ParseJsonKeys(json string, key string) ([]string, error) {
+	return _VmSafe.Contract.ParseJsonKeys(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonKeys is a free data retrieval call binding the contract method 0x213e4198.
+//
+// Solidity: function parseJsonKeys(string json, string key) pure returns(string[] keys)
+func (_VmSafe *VmSafeCallerSession) ParseJsonKeys(json string, key string) ([]string, error) {
+	return _VmSafe.Contract.ParseJsonKeys(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonString is a free data retrieval call binding the contract method 0x49c4fac8.
+//
+// Solidity: function parseJsonString(string json, string key) pure returns(string)
+func (_VmSafe *VmSafeCaller) ParseJsonString(opts *bind.CallOpts, json string, key string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonString", json, key)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ParseJsonString is a free data retrieval call binding the contract method 0x49c4fac8.
+//
+// Solidity: function parseJsonString(string json, string key) pure returns(string)
+func (_VmSafe *VmSafeSession) ParseJsonString(json string, key string) (string, error) {
+	return _VmSafe.Contract.ParseJsonString(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonString is a free data retrieval call binding the contract method 0x49c4fac8.
+//
+// Solidity: function parseJsonString(string json, string key) pure returns(string)
+func (_VmSafe *VmSafeCallerSession) ParseJsonString(json string, key string) (string, error) {
+	return _VmSafe.Contract.ParseJsonString(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonStringArray is a free data retrieval call binding the contract method 0x498fdcf4.
+//
+// Solidity: function parseJsonStringArray(string json, string key) pure returns(string[])
+func (_VmSafe *VmSafeCaller) ParseJsonStringArray(opts *bind.CallOpts, json string, key string) ([]string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonStringArray", json, key)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ParseJsonStringArray is a free data retrieval call binding the contract method 0x498fdcf4.
+//
+// Solidity: function parseJsonStringArray(string json, string key) pure returns(string[])
+func (_VmSafe *VmSafeSession) ParseJsonStringArray(json string, key string) ([]string, error) {
+	return _VmSafe.Contract.ParseJsonStringArray(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonStringArray is a free data retrieval call binding the contract method 0x498fdcf4.
+//
+// Solidity: function parseJsonStringArray(string json, string key) pure returns(string[])
+func (_VmSafe *VmSafeCallerSession) ParseJsonStringArray(json string, key string) ([]string, error) {
+	return _VmSafe.Contract.ParseJsonStringArray(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonType is a free data retrieval call binding the contract method 0xa9da313b.
+//
+// Solidity: function parseJsonType(string json, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeCaller) ParseJsonType(opts *bind.CallOpts, json string, typeDescription string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonType", json, typeDescription)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonType is a free data retrieval call binding the contract method 0xa9da313b.
+//
+// Solidity: function parseJsonType(string json, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeSession) ParseJsonType(json string, typeDescription string) ([]byte, error) {
+	return _VmSafe.Contract.ParseJsonType(&_VmSafe.CallOpts, json, typeDescription)
+}
+
+// ParseJsonType is a free data retrieval call binding the contract method 0xa9da313b.
+//
+// Solidity: function parseJsonType(string json, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeCallerSession) ParseJsonType(json string, typeDescription string) ([]byte, error) {
+	return _VmSafe.Contract.ParseJsonType(&_VmSafe.CallOpts, json, typeDescription)
+}
+
+// ParseJsonType0 is a free data retrieval call binding the contract method 0xe3f5ae33.
+//
+// Solidity: function parseJsonType(string json, string key, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeCaller) ParseJsonType0(opts *bind.CallOpts, json string, key string, typeDescription string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonType0", json, key, typeDescription)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonType0 is a free data retrieval call binding the contract method 0xe3f5ae33.
+//
+// Solidity: function parseJsonType(string json, string key, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeSession) ParseJsonType0(json string, key string, typeDescription string) ([]byte, error) {
+	return _VmSafe.Contract.ParseJsonType0(&_VmSafe.CallOpts, json, key, typeDescription)
+}
+
+// ParseJsonType0 is a free data retrieval call binding the contract method 0xe3f5ae33.
+//
+// Solidity: function parseJsonType(string json, string key, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeCallerSession) ParseJsonType0(json string, key string, typeDescription string) ([]byte, error) {
+	return _VmSafe.Contract.ParseJsonType0(&_VmSafe.CallOpts, json, key, typeDescription)
+}
+
+// ParseJsonTypeArray is a free data retrieval call binding the contract method 0x0175d535.
+//
+// Solidity: function parseJsonTypeArray(string json, string key, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeCaller) ParseJsonTypeArray(opts *bind.CallOpts, json string, key string, typeDescription string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonTypeArray", json, key, typeDescription)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseJsonTypeArray is a free data retrieval call binding the contract method 0x0175d535.
+//
+// Solidity: function parseJsonTypeArray(string json, string key, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeSession) ParseJsonTypeArray(json string, key string, typeDescription string) ([]byte, error) {
+	return _VmSafe.Contract.ParseJsonTypeArray(&_VmSafe.CallOpts, json, key, typeDescription)
+}
+
+// ParseJsonTypeArray is a free data retrieval call binding the contract method 0x0175d535.
+//
+// Solidity: function parseJsonTypeArray(string json, string key, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeCallerSession) ParseJsonTypeArray(json string, key string, typeDescription string) ([]byte, error) {
+	return _VmSafe.Contract.ParseJsonTypeArray(&_VmSafe.CallOpts, json, key, typeDescription)
+}
+
+// ParseJsonUint is a free data retrieval call binding the contract method 0xaddde2b6.
+//
+// Solidity: function parseJsonUint(string json, string key) pure returns(uint256)
+func (_VmSafe *VmSafeCaller) ParseJsonUint(opts *bind.CallOpts, json string, key string) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonUint", json, key)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ParseJsonUint is a free data retrieval call binding the contract method 0xaddde2b6.
+//
+// Solidity: function parseJsonUint(string json, string key) pure returns(uint256)
+func (_VmSafe *VmSafeSession) ParseJsonUint(json string, key string) (*big.Int, error) {
+	return _VmSafe.Contract.ParseJsonUint(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonUint is a free data retrieval call binding the contract method 0xaddde2b6.
+//
+// Solidity: function parseJsonUint(string json, string key) pure returns(uint256)
+func (_VmSafe *VmSafeCallerSession) ParseJsonUint(json string, key string) (*big.Int, error) {
+	return _VmSafe.Contract.ParseJsonUint(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonUintArray is a free data retrieval call binding the contract method 0x522074ab.
+//
+// Solidity: function parseJsonUintArray(string json, string key) pure returns(uint256[])
+func (_VmSafe *VmSafeCaller) ParseJsonUintArray(opts *bind.CallOpts, json string, key string) ([]*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseJsonUintArray", json, key)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// ParseJsonUintArray is a free data retrieval call binding the contract method 0x522074ab.
+//
+// Solidity: function parseJsonUintArray(string json, string key) pure returns(uint256[])
+func (_VmSafe *VmSafeSession) ParseJsonUintArray(json string, key string) ([]*big.Int, error) {
+	return _VmSafe.Contract.ParseJsonUintArray(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseJsonUintArray is a free data retrieval call binding the contract method 0x522074ab.
+//
+// Solidity: function parseJsonUintArray(string json, string key) pure returns(uint256[])
+func (_VmSafe *VmSafeCallerSession) ParseJsonUintArray(json string, key string) ([]*big.Int, error) {
+	return _VmSafe.Contract.ParseJsonUintArray(&_VmSafe.CallOpts, json, key)
+}
+
+// ParseToml is a free data retrieval call binding the contract method 0x37736e08.
+//
+// Solidity: function parseToml(string toml, string key) pure returns(bytes abiEncodedData)
+func (_VmSafe *VmSafeCaller) ParseToml(opts *bind.CallOpts, toml string, key string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseToml", toml, key)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseToml is a free data retrieval call binding the contract method 0x37736e08.
+//
+// Solidity: function parseToml(string toml, string key) pure returns(bytes abiEncodedData)
+func (_VmSafe *VmSafeSession) ParseToml(toml string, key string) ([]byte, error) {
+	return _VmSafe.Contract.ParseToml(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseToml is a free data retrieval call binding the contract method 0x37736e08.
+//
+// Solidity: function parseToml(string toml, string key) pure returns(bytes abiEncodedData)
+func (_VmSafe *VmSafeCallerSession) ParseToml(toml string, key string) ([]byte, error) {
+	return _VmSafe.Contract.ParseToml(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseToml0 is a free data retrieval call binding the contract method 0x592151f0.
+//
+// Solidity: function parseToml(string toml) pure returns(bytes abiEncodedData)
+func (_VmSafe *VmSafeCaller) ParseToml0(opts *bind.CallOpts, toml string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseToml0", toml)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseToml0 is a free data retrieval call binding the contract method 0x592151f0.
+//
+// Solidity: function parseToml(string toml) pure returns(bytes abiEncodedData)
+func (_VmSafe *VmSafeSession) ParseToml0(toml string) ([]byte, error) {
+	return _VmSafe.Contract.ParseToml0(&_VmSafe.CallOpts, toml)
+}
+
+// ParseToml0 is a free data retrieval call binding the contract method 0x592151f0.
+//
+// Solidity: function parseToml(string toml) pure returns(bytes abiEncodedData)
+func (_VmSafe *VmSafeCallerSession) ParseToml0(toml string) ([]byte, error) {
+	return _VmSafe.Contract.ParseToml0(&_VmSafe.CallOpts, toml)
+}
+
+// ParseTomlAddress is a free data retrieval call binding the contract method 0x65e7c844.
+//
+// Solidity: function parseTomlAddress(string toml, string key) pure returns(address)
+func (_VmSafe *VmSafeCaller) ParseTomlAddress(opts *bind.CallOpts, toml string, key string) (common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlAddress", toml, key)
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// ParseTomlAddress is a free data retrieval call binding the contract method 0x65e7c844.
+//
+// Solidity: function parseTomlAddress(string toml, string key) pure returns(address)
+func (_VmSafe *VmSafeSession) ParseTomlAddress(toml string, key string) (common.Address, error) {
+	return _VmSafe.Contract.ParseTomlAddress(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlAddress is a free data retrieval call binding the contract method 0x65e7c844.
+//
+// Solidity: function parseTomlAddress(string toml, string key) pure returns(address)
+func (_VmSafe *VmSafeCallerSession) ParseTomlAddress(toml string, key string) (common.Address, error) {
+	return _VmSafe.Contract.ParseTomlAddress(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlAddressArray is a free data retrieval call binding the contract method 0x65c428e7.
+//
+// Solidity: function parseTomlAddressArray(string toml, string key) pure returns(address[])
+func (_VmSafe *VmSafeCaller) ParseTomlAddressArray(opts *bind.CallOpts, toml string, key string) ([]common.Address, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlAddressArray", toml, key)
+
+	if err != nil {
+		return *new([]common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
+
+	return out0, err
+
+}
+
+// ParseTomlAddressArray is a free data retrieval call binding the contract method 0x65c428e7.
+//
+// Solidity: function parseTomlAddressArray(string toml, string key) pure returns(address[])
+func (_VmSafe *VmSafeSession) ParseTomlAddressArray(toml string, key string) ([]common.Address, error) {
+	return _VmSafe.Contract.ParseTomlAddressArray(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlAddressArray is a free data retrieval call binding the contract method 0x65c428e7.
+//
+// Solidity: function parseTomlAddressArray(string toml, string key) pure returns(address[])
+func (_VmSafe *VmSafeCallerSession) ParseTomlAddressArray(toml string, key string) ([]common.Address, error) {
+	return _VmSafe.Contract.ParseTomlAddressArray(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlBool is a free data retrieval call binding the contract method 0xd30dced6.
+//
+// Solidity: function parseTomlBool(string toml, string key) pure returns(bool)
+func (_VmSafe *VmSafeCaller) ParseTomlBool(opts *bind.CallOpts, toml string, key string) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlBool", toml, key)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// ParseTomlBool is a free data retrieval call binding the contract method 0xd30dced6.
+//
+// Solidity: function parseTomlBool(string toml, string key) pure returns(bool)
+func (_VmSafe *VmSafeSession) ParseTomlBool(toml string, key string) (bool, error) {
+	return _VmSafe.Contract.ParseTomlBool(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlBool is a free data retrieval call binding the contract method 0xd30dced6.
+//
+// Solidity: function parseTomlBool(string toml, string key) pure returns(bool)
+func (_VmSafe *VmSafeCallerSession) ParseTomlBool(toml string, key string) (bool, error) {
+	return _VmSafe.Contract.ParseTomlBool(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlBoolArray is a free data retrieval call binding the contract method 0x127cfe9a.
+//
+// Solidity: function parseTomlBoolArray(string toml, string key) pure returns(bool[])
+func (_VmSafe *VmSafeCaller) ParseTomlBoolArray(opts *bind.CallOpts, toml string, key string) ([]bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlBoolArray", toml, key)
+
+	if err != nil {
+		return *new([]bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool)
+
+	return out0, err
+
+}
+
+// ParseTomlBoolArray is a free data retrieval call binding the contract method 0x127cfe9a.
+//
+// Solidity: function parseTomlBoolArray(string toml, string key) pure returns(bool[])
+func (_VmSafe *VmSafeSession) ParseTomlBoolArray(toml string, key string) ([]bool, error) {
+	return _VmSafe.Contract.ParseTomlBoolArray(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlBoolArray is a free data retrieval call binding the contract method 0x127cfe9a.
+//
+// Solidity: function parseTomlBoolArray(string toml, string key) pure returns(bool[])
+func (_VmSafe *VmSafeCallerSession) ParseTomlBoolArray(toml string, key string) ([]bool, error) {
+	return _VmSafe.Contract.ParseTomlBoolArray(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlBytes is a free data retrieval call binding the contract method 0xd77bfdb9.
+//
+// Solidity: function parseTomlBytes(string toml, string key) pure returns(bytes)
+func (_VmSafe *VmSafeCaller) ParseTomlBytes(opts *bind.CallOpts, toml string, key string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlBytes", toml, key)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlBytes is a free data retrieval call binding the contract method 0xd77bfdb9.
+//
+// Solidity: function parseTomlBytes(string toml, string key) pure returns(bytes)
+func (_VmSafe *VmSafeSession) ParseTomlBytes(toml string, key string) ([]byte, error) {
+	return _VmSafe.Contract.ParseTomlBytes(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlBytes is a free data retrieval call binding the contract method 0xd77bfdb9.
+//
+// Solidity: function parseTomlBytes(string toml, string key) pure returns(bytes)
+func (_VmSafe *VmSafeCallerSession) ParseTomlBytes(toml string, key string) ([]byte, error) {
+	return _VmSafe.Contract.ParseTomlBytes(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlBytes32 is a free data retrieval call binding the contract method 0x8e214810.
+//
+// Solidity: function parseTomlBytes32(string toml, string key) pure returns(bytes32)
+func (_VmSafe *VmSafeCaller) ParseTomlBytes32(opts *bind.CallOpts, toml string, key string) ([32]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlBytes32", toml, key)
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlBytes32 is a free data retrieval call binding the contract method 0x8e214810.
+//
+// Solidity: function parseTomlBytes32(string toml, string key) pure returns(bytes32)
+func (_VmSafe *VmSafeSession) ParseTomlBytes32(toml string, key string) ([32]byte, error) {
+	return _VmSafe.Contract.ParseTomlBytes32(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlBytes32 is a free data retrieval call binding the contract method 0x8e214810.
+//
+// Solidity: function parseTomlBytes32(string toml, string key) pure returns(bytes32)
+func (_VmSafe *VmSafeCallerSession) ParseTomlBytes32(toml string, key string) ([32]byte, error) {
+	return _VmSafe.Contract.ParseTomlBytes32(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlBytes32Array is a free data retrieval call binding the contract method 0x3e716f81.
+//
+// Solidity: function parseTomlBytes32Array(string toml, string key) pure returns(bytes32[])
+func (_VmSafe *VmSafeCaller) ParseTomlBytes32Array(opts *bind.CallOpts, toml string, key string) ([][32]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlBytes32Array", toml, key)
+
+	if err != nil {
+		return *new([][32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlBytes32Array is a free data retrieval call binding the contract method 0x3e716f81.
+//
+// Solidity: function parseTomlBytes32Array(string toml, string key) pure returns(bytes32[])
+func (_VmSafe *VmSafeSession) ParseTomlBytes32Array(toml string, key string) ([][32]byte, error) {
+	return _VmSafe.Contract.ParseTomlBytes32Array(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlBytes32Array is a free data retrieval call binding the contract method 0x3e716f81.
+//
+// Solidity: function parseTomlBytes32Array(string toml, string key) pure returns(bytes32[])
+func (_VmSafe *VmSafeCallerSession) ParseTomlBytes32Array(toml string, key string) ([][32]byte, error) {
+	return _VmSafe.Contract.ParseTomlBytes32Array(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlBytesArray is a free data retrieval call binding the contract method 0xb197c247.
+//
+// Solidity: function parseTomlBytesArray(string toml, string key) pure returns(bytes[])
+func (_VmSafe *VmSafeCaller) ParseTomlBytesArray(opts *bind.CallOpts, toml string, key string) ([][]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlBytesArray", toml, key)
+
+	if err != nil {
+		return *new([][]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlBytesArray is a free data retrieval call binding the contract method 0xb197c247.
+//
+// Solidity: function parseTomlBytesArray(string toml, string key) pure returns(bytes[])
+func (_VmSafe *VmSafeSession) ParseTomlBytesArray(toml string, key string) ([][]byte, error) {
+	return _VmSafe.Contract.ParseTomlBytesArray(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlBytesArray is a free data retrieval call binding the contract method 0xb197c247.
+//
+// Solidity: function parseTomlBytesArray(string toml, string key) pure returns(bytes[])
+func (_VmSafe *VmSafeCallerSession) ParseTomlBytesArray(toml string, key string) ([][]byte, error) {
+	return _VmSafe.Contract.ParseTomlBytesArray(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlInt is a free data retrieval call binding the contract method 0xc1350739.
+//
+// Solidity: function parseTomlInt(string toml, string key) pure returns(int256)
+func (_VmSafe *VmSafeCaller) ParseTomlInt(opts *bind.CallOpts, toml string, key string) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlInt", toml, key)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ParseTomlInt is a free data retrieval call binding the contract method 0xc1350739.
+//
+// Solidity: function parseTomlInt(string toml, string key) pure returns(int256)
+func (_VmSafe *VmSafeSession) ParseTomlInt(toml string, key string) (*big.Int, error) {
+	return _VmSafe.Contract.ParseTomlInt(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlInt is a free data retrieval call binding the contract method 0xc1350739.
+//
+// Solidity: function parseTomlInt(string toml, string key) pure returns(int256)
+func (_VmSafe *VmSafeCallerSession) ParseTomlInt(toml string, key string) (*big.Int, error) {
+	return _VmSafe.Contract.ParseTomlInt(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlIntArray is a free data retrieval call binding the contract method 0xd3522ae6.
+//
+// Solidity: function parseTomlIntArray(string toml, string key) pure returns(int256[])
+func (_VmSafe *VmSafeCaller) ParseTomlIntArray(opts *bind.CallOpts, toml string, key string) ([]*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlIntArray", toml, key)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// ParseTomlIntArray is a free data retrieval call binding the contract method 0xd3522ae6.
+//
+// Solidity: function parseTomlIntArray(string toml, string key) pure returns(int256[])
+func (_VmSafe *VmSafeSession) ParseTomlIntArray(toml string, key string) ([]*big.Int, error) {
+	return _VmSafe.Contract.ParseTomlIntArray(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlIntArray is a free data retrieval call binding the contract method 0xd3522ae6.
+//
+// Solidity: function parseTomlIntArray(string toml, string key) pure returns(int256[])
+func (_VmSafe *VmSafeCallerSession) ParseTomlIntArray(toml string, key string) ([]*big.Int, error) {
+	return _VmSafe.Contract.ParseTomlIntArray(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlKeys is a free data retrieval call binding the contract method 0x812a44b2.
+//
+// Solidity: function parseTomlKeys(string toml, string key) pure returns(string[] keys)
+func (_VmSafe *VmSafeCaller) ParseTomlKeys(opts *bind.CallOpts, toml string, key string) ([]string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlKeys", toml, key)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ParseTomlKeys is a free data retrieval call binding the contract method 0x812a44b2.
+//
+// Solidity: function parseTomlKeys(string toml, string key) pure returns(string[] keys)
+func (_VmSafe *VmSafeSession) ParseTomlKeys(toml string, key string) ([]string, error) {
+	return _VmSafe.Contract.ParseTomlKeys(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlKeys is a free data retrieval call binding the contract method 0x812a44b2.
+//
+// Solidity: function parseTomlKeys(string toml, string key) pure returns(string[] keys)
+func (_VmSafe *VmSafeCallerSession) ParseTomlKeys(toml string, key string) ([]string, error) {
+	return _VmSafe.Contract.ParseTomlKeys(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlString is a free data retrieval call binding the contract method 0x8bb8dd43.
+//
+// Solidity: function parseTomlString(string toml, string key) pure returns(string)
+func (_VmSafe *VmSafeCaller) ParseTomlString(opts *bind.CallOpts, toml string, key string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlString", toml, key)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ParseTomlString is a free data retrieval call binding the contract method 0x8bb8dd43.
+//
+// Solidity: function parseTomlString(string toml, string key) pure returns(string)
+func (_VmSafe *VmSafeSession) ParseTomlString(toml string, key string) (string, error) {
+	return _VmSafe.Contract.ParseTomlString(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlString is a free data retrieval call binding the contract method 0x8bb8dd43.
+//
+// Solidity: function parseTomlString(string toml, string key) pure returns(string)
+func (_VmSafe *VmSafeCallerSession) ParseTomlString(toml string, key string) (string, error) {
+	return _VmSafe.Contract.ParseTomlString(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlStringArray is a free data retrieval call binding the contract method 0x9f629281.
+//
+// Solidity: function parseTomlStringArray(string toml, string key) pure returns(string[])
+func (_VmSafe *VmSafeCaller) ParseTomlStringArray(opts *bind.CallOpts, toml string, key string) ([]string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlStringArray", toml, key)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// ParseTomlStringArray is a free data retrieval call binding the contract method 0x9f629281.
+//
+// Solidity: function parseTomlStringArray(string toml, string key) pure returns(string[])
+func (_VmSafe *VmSafeSession) ParseTomlStringArray(toml string, key string) ([]string, error) {
+	return _VmSafe.Contract.ParseTomlStringArray(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlStringArray is a free data retrieval call binding the contract method 0x9f629281.
+//
+// Solidity: function parseTomlStringArray(string toml, string key) pure returns(string[])
+func (_VmSafe *VmSafeCallerSession) ParseTomlStringArray(toml string, key string) ([]string, error) {
+	return _VmSafe.Contract.ParseTomlStringArray(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlType is a free data retrieval call binding the contract method 0x47fa5e11.
+//
+// Solidity: function parseTomlType(string toml, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeCaller) ParseTomlType(opts *bind.CallOpts, toml string, typeDescription string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlType", toml, typeDescription)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlType is a free data retrieval call binding the contract method 0x47fa5e11.
+//
+// Solidity: function parseTomlType(string toml, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeSession) ParseTomlType(toml string, typeDescription string) ([]byte, error) {
+	return _VmSafe.Contract.ParseTomlType(&_VmSafe.CallOpts, toml, typeDescription)
+}
+
+// ParseTomlType is a free data retrieval call binding the contract method 0x47fa5e11.
+//
+// Solidity: function parseTomlType(string toml, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeCallerSession) ParseTomlType(toml string, typeDescription string) ([]byte, error) {
+	return _VmSafe.Contract.ParseTomlType(&_VmSafe.CallOpts, toml, typeDescription)
+}
+
+// ParseTomlType0 is a free data retrieval call binding the contract method 0xf9fa5cdb.
+//
+// Solidity: function parseTomlType(string toml, string key, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeCaller) ParseTomlType0(opts *bind.CallOpts, toml string, key string, typeDescription string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlType0", toml, key, typeDescription)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlType0 is a free data retrieval call binding the contract method 0xf9fa5cdb.
+//
+// Solidity: function parseTomlType(string toml, string key, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeSession) ParseTomlType0(toml string, key string, typeDescription string) ([]byte, error) {
+	return _VmSafe.Contract.ParseTomlType0(&_VmSafe.CallOpts, toml, key, typeDescription)
+}
+
+// ParseTomlType0 is a free data retrieval call binding the contract method 0xf9fa5cdb.
+//
+// Solidity: function parseTomlType(string toml, string key, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeCallerSession) ParseTomlType0(toml string, key string, typeDescription string) ([]byte, error) {
+	return _VmSafe.Contract.ParseTomlType0(&_VmSafe.CallOpts, toml, key, typeDescription)
+}
+
+// ParseTomlTypeArray is a free data retrieval call binding the contract method 0x49be3743.
+//
+// Solidity: function parseTomlTypeArray(string toml, string key, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeCaller) ParseTomlTypeArray(opts *bind.CallOpts, toml string, key string, typeDescription string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlTypeArray", toml, key, typeDescription)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ParseTomlTypeArray is a free data retrieval call binding the contract method 0x49be3743.
+//
+// Solidity: function parseTomlTypeArray(string toml, string key, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeSession) ParseTomlTypeArray(toml string, key string, typeDescription string) ([]byte, error) {
+	return _VmSafe.Contract.ParseTomlTypeArray(&_VmSafe.CallOpts, toml, key, typeDescription)
+}
+
+// ParseTomlTypeArray is a free data retrieval call binding the contract method 0x49be3743.
+//
+// Solidity: function parseTomlTypeArray(string toml, string key, string typeDescription) pure returns(bytes)
+func (_VmSafe *VmSafeCallerSession) ParseTomlTypeArray(toml string, key string, typeDescription string) ([]byte, error) {
+	return _VmSafe.Contract.ParseTomlTypeArray(&_VmSafe.CallOpts, toml, key, typeDescription)
+}
+
+// ParseTomlUint is a free data retrieval call binding the contract method 0xcc7b0487.
+//
+// Solidity: function parseTomlUint(string toml, string key) pure returns(uint256)
+func (_VmSafe *VmSafeCaller) ParseTomlUint(opts *bind.CallOpts, toml string, key string) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlUint", toml, key)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ParseTomlUint is a free data retrieval call binding the contract method 0xcc7b0487.
+//
+// Solidity: function parseTomlUint(string toml, string key) pure returns(uint256)
+func (_VmSafe *VmSafeSession) ParseTomlUint(toml string, key string) (*big.Int, error) {
+	return _VmSafe.Contract.ParseTomlUint(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlUint is a free data retrieval call binding the contract method 0xcc7b0487.
+//
+// Solidity: function parseTomlUint(string toml, string key) pure returns(uint256)
+func (_VmSafe *VmSafeCallerSession) ParseTomlUint(toml string, key string) (*big.Int, error) {
+	return _VmSafe.Contract.ParseTomlUint(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlUintArray is a free data retrieval call binding the contract method 0xb5df27c8.
+//
+// Solidity: function parseTomlUintArray(string toml, string key) pure returns(uint256[])
+func (_VmSafe *VmSafeCaller) ParseTomlUintArray(opts *bind.CallOpts, toml string, key string) ([]*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseTomlUintArray", toml, key)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// ParseTomlUintArray is a free data retrieval call binding the contract method 0xb5df27c8.
+//
+// Solidity: function parseTomlUintArray(string toml, string key) pure returns(uint256[])
+func (_VmSafe *VmSafeSession) ParseTomlUintArray(toml string, key string) ([]*big.Int, error) {
+	return _VmSafe.Contract.ParseTomlUintArray(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseTomlUintArray is a free data retrieval call binding the contract method 0xb5df27c8.
+//
+// Solidity: function parseTomlUintArray(string toml, string key) pure returns(uint256[])
+func (_VmSafe *VmSafeCallerSession) ParseTomlUintArray(toml string, key string) ([]*big.Int, error) {
+	return _VmSafe.Contract.ParseTomlUintArray(&_VmSafe.CallOpts, toml, key)
+}
+
+// ParseUint is a free data retrieval call binding the contract method 0xfa91454d.
+//
+// Solidity: function parseUint(string stringifiedValue) pure returns(uint256 parsedValue)
+func (_VmSafe *VmSafeCaller) ParseUint(opts *bind.CallOpts, stringifiedValue string) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "parseUint", stringifiedValue)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// ParseUint is a free data retrieval call binding the contract method 0xfa91454d.
+//
+// Solidity: function parseUint(string stringifiedValue) pure returns(uint256 parsedValue)
+func (_VmSafe *VmSafeSession) ParseUint(stringifiedValue string) (*big.Int, error) {
+	return _VmSafe.Contract.ParseUint(&_VmSafe.CallOpts, stringifiedValue)
+}
+
+// ParseUint is a free data retrieval call binding the contract method 0xfa91454d.
+//
+// Solidity: function parseUint(string stringifiedValue) pure returns(uint256 parsedValue)
+func (_VmSafe *VmSafeCallerSession) ParseUint(stringifiedValue string) (*big.Int, error) {
+	return _VmSafe.Contract.ParseUint(&_VmSafe.CallOpts, stringifiedValue)
+}
+
+// PauseTracing is a free data retrieval call binding the contract method 0xc94d1f90.
+//
+// Solidity: function pauseTracing() view returns()
+func (_VmSafe *VmSafeCaller) PauseTracing(opts *bind.CallOpts) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "pauseTracing")
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// PauseTracing is a free data retrieval call binding the contract method 0xc94d1f90.
+//
+// Solidity: function pauseTracing() view returns()
+func (_VmSafe *VmSafeSession) PauseTracing() error {
+	return _VmSafe.Contract.PauseTracing(&_VmSafe.CallOpts)
+}
+
+// PauseTracing is a free data retrieval call binding the contract method 0xc94d1f90.
+//
+// Solidity: function pauseTracing() view returns()
+func (_VmSafe *VmSafeCallerSession) PauseTracing() error {
+	return _VmSafe.Contract.PauseTracing(&_VmSafe.CallOpts)
+}
+
+// ProjectRoot is a free data retrieval call binding the contract method 0xd930a0e6.
+//
+// Solidity: function projectRoot() view returns(string path)
+func (_VmSafe *VmSafeCaller) ProjectRoot(opts *bind.CallOpts) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "projectRoot")
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ProjectRoot is a free data retrieval call binding the contract method 0xd930a0e6.
+//
+// Solidity: function projectRoot() view returns(string path)
+func (_VmSafe *VmSafeSession) ProjectRoot() (string, error) {
+	return _VmSafe.Contract.ProjectRoot(&_VmSafe.CallOpts)
+}
+
+// ProjectRoot is a free data retrieval call binding the contract method 0xd930a0e6.
+//
+// Solidity: function projectRoot() view returns(string path)
+func (_VmSafe *VmSafeCallerSession) ProjectRoot() (string, error) {
+	return _VmSafe.Contract.ProjectRoot(&_VmSafe.CallOpts)
+}
+
+// PublicKeyP256 is a free data retrieval call binding the contract method 0xc453949e.
+//
+// Solidity: function publicKeyP256(uint256 privateKey) pure returns(uint256 publicKeyX, uint256 publicKeyY)
+func (_VmSafe *VmSafeCaller) PublicKeyP256(opts *bind.CallOpts, privateKey *big.Int) (struct {
+	PublicKeyX *big.Int
+	PublicKeyY *big.Int
+}, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "publicKeyP256", privateKey)
+
+	outstruct := new(struct {
+		PublicKeyX *big.Int
+		PublicKeyY *big.Int
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.PublicKeyX = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+	outstruct.PublicKeyY = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int)
+
+	return *outstruct, err
+
+}
+
+// PublicKeyP256 is a free data retrieval call binding the contract method 0xc453949e.
+//
+// Solidity: function publicKeyP256(uint256 privateKey) pure returns(uint256 publicKeyX, uint256 publicKeyY)
+func (_VmSafe *VmSafeSession) PublicKeyP256(privateKey *big.Int) (struct {
+	PublicKeyX *big.Int
+	PublicKeyY *big.Int
+}, error) {
+	return _VmSafe.Contract.PublicKeyP256(&_VmSafe.CallOpts, privateKey)
+}
+
+// PublicKeyP256 is a free data retrieval call binding the contract method 0xc453949e.
+//
+// Solidity: function publicKeyP256(uint256 privateKey) pure returns(uint256 publicKeyX, uint256 publicKeyY)
+func (_VmSafe *VmSafeCallerSession) PublicKeyP256(privateKey *big.Int) (struct {
+	PublicKeyX *big.Int
+	PublicKeyY *big.Int
+}, error) {
+	return _VmSafe.Contract.PublicKeyP256(&_VmSafe.CallOpts, privateKey)
+}
+
+// RandomBool is a free data retrieval call binding the contract method 0xcdc126bd.
+//
+// Solidity: function randomBool() view returns(bool)
+func (_VmSafe *VmSafeCaller) RandomBool(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "randomBool")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// RandomBool is a free data retrieval call binding the contract method 0xcdc126bd.
+//
+// Solidity: function randomBool() view returns(bool)
+func (_VmSafe *VmSafeSession) RandomBool() (bool, error) {
+	return _VmSafe.Contract.RandomBool(&_VmSafe.CallOpts)
+}
+
+// RandomBool is a free data retrieval call binding the contract method 0xcdc126bd.
+//
+// Solidity: function randomBool() view returns(bool)
+func (_VmSafe *VmSafeCallerSession) RandomBool() (bool, error) {
+	return _VmSafe.Contract.RandomBool(&_VmSafe.CallOpts)
+}
+
+// RandomBytes is a free data retrieval call binding the contract method 0x6c5d32a9.
+//
+// Solidity: function randomBytes(uint256 len) view returns(bytes)
+func (_VmSafe *VmSafeCaller) RandomBytes(opts *bind.CallOpts, len *big.Int) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "randomBytes", len)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// RandomBytes is a free data retrieval call binding the contract method 0x6c5d32a9.
+//
+// Solidity: function randomBytes(uint256 len) view returns(bytes)
+func (_VmSafe *VmSafeSession) RandomBytes(len *big.Int) ([]byte, error) {
+	return _VmSafe.Contract.RandomBytes(&_VmSafe.CallOpts, len)
+}
+
+// RandomBytes is a free data retrieval call binding the contract method 0x6c5d32a9.
+//
+// Solidity: function randomBytes(uint256 len) view returns(bytes)
+func (_VmSafe *VmSafeCallerSession) RandomBytes(len *big.Int) ([]byte, error) {
+	return _VmSafe.Contract.RandomBytes(&_VmSafe.CallOpts, len)
+}
+
+// RandomBytes4 is a free data retrieval call binding the contract method 0x9b7cd579.
+//
+// Solidity: function randomBytes4() view returns(bytes4)
+func (_VmSafe *VmSafeCaller) RandomBytes4(opts *bind.CallOpts) ([4]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "randomBytes4")
+
+	if err != nil {
+		return *new([4]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([4]byte)).(*[4]byte)
+
+	return out0, err
+
+}
+
+// RandomBytes4 is a free data retrieval call binding the contract method 0x9b7cd579.
+//
+// Solidity: function randomBytes4() view returns(bytes4)
+func (_VmSafe *VmSafeSession) RandomBytes4() ([4]byte, error) {
+	return _VmSafe.Contract.RandomBytes4(&_VmSafe.CallOpts)
+}
+
+// RandomBytes4 is a free data retrieval call binding the contract method 0x9b7cd579.
+//
+// Solidity: function randomBytes4() view returns(bytes4)
+func (_VmSafe *VmSafeCallerSession) RandomBytes4() ([4]byte, error) {
+	return _VmSafe.Contract.RandomBytes4(&_VmSafe.CallOpts)
+}
+
+// RandomBytes8 is a free data retrieval call binding the contract method 0x0497b0a5.
+//
+// Solidity: function randomBytes8() view returns(bytes8)
+func (_VmSafe *VmSafeCaller) RandomBytes8(opts *bind.CallOpts) ([8]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "randomBytes8")
+
+	if err != nil {
+		return *new([8]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([8]byte)).(*[8]byte)
+
+	return out0, err
+
+}
+
+// RandomBytes8 is a free data retrieval call binding the contract method 0x0497b0a5.
+//
+// Solidity: function randomBytes8() view returns(bytes8)
+func (_VmSafe *VmSafeSession) RandomBytes8() ([8]byte, error) {
+	return _VmSafe.Contract.RandomBytes8(&_VmSafe.CallOpts)
+}
+
+// RandomBytes8 is a free data retrieval call binding the contract method 0x0497b0a5.
+//
+// Solidity: function randomBytes8() view returns(bytes8)
+func (_VmSafe *VmSafeCallerSession) RandomBytes8() ([8]byte, error) {
+	return _VmSafe.Contract.RandomBytes8(&_VmSafe.CallOpts)
+}
+
+// RandomInt is a free data retrieval call binding the contract method 0x111f1202.
+//
+// Solidity: function randomInt() view returns(int256)
+func (_VmSafe *VmSafeCaller) RandomInt(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "randomInt")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// RandomInt is a free data retrieval call binding the contract method 0x111f1202.
+//
+// Solidity: function randomInt() view returns(int256)
+func (_VmSafe *VmSafeSession) RandomInt() (*big.Int, error) {
+	return _VmSafe.Contract.RandomInt(&_VmSafe.CallOpts)
+}
+
+// RandomInt is a free data retrieval call binding the contract method 0x111f1202.
+//
+// Solidity: function randomInt() view returns(int256)
+func (_VmSafe *VmSafeCallerSession) RandomInt() (*big.Int, error) {
+	return _VmSafe.Contract.RandomInt(&_VmSafe.CallOpts)
+}
+
+// RandomInt0 is a free data retrieval call binding the contract method 0x12845966.
+//
+// Solidity: function randomInt(uint256 bits) view returns(int256)
+func (_VmSafe *VmSafeCaller) RandomInt0(opts *bind.CallOpts, bits *big.Int) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "randomInt0", bits)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// RandomInt0 is a free data retrieval call binding the contract method 0x12845966.
+//
+// Solidity: function randomInt(uint256 bits) view returns(int256)
+func (_VmSafe *VmSafeSession) RandomInt0(bits *big.Int) (*big.Int, error) {
+	return _VmSafe.Contract.RandomInt0(&_VmSafe.CallOpts, bits)
+}
+
+// RandomInt0 is a free data retrieval call binding the contract method 0x12845966.
+//
+// Solidity: function randomInt(uint256 bits) view returns(int256)
+func (_VmSafe *VmSafeCallerSession) RandomInt0(bits *big.Int) (*big.Int, error) {
+	return _VmSafe.Contract.RandomInt0(&_VmSafe.CallOpts, bits)
+}
+
+// RandomUint0 is a free data retrieval call binding the contract method 0xcf81e69c.
+//
+// Solidity: function randomUint(uint256 bits) view returns(uint256)
+func (_VmSafe *VmSafeCaller) RandomUint0(opts *bind.CallOpts, bits *big.Int) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "randomUint0", bits)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// RandomUint0 is a free data retrieval call binding the contract method 0xcf81e69c.
+//
+// Solidity: function randomUint(uint256 bits) view returns(uint256)
+func (_VmSafe *VmSafeSession) RandomUint0(bits *big.Int) (*big.Int, error) {
+	return _VmSafe.Contract.RandomUint0(&_VmSafe.CallOpts, bits)
+}
+
+// RandomUint0 is a free data retrieval call binding the contract method 0xcf81e69c.
+//
+// Solidity: function randomUint(uint256 bits) view returns(uint256)
+func (_VmSafe *VmSafeCallerSession) RandomUint0(bits *big.Int) (*big.Int, error) {
+	return _VmSafe.Contract.RandomUint0(&_VmSafe.CallOpts, bits)
+}
+
+// ReadDir is a free data retrieval call binding the contract method 0x1497876c.
+//
+// Solidity: function readDir(string path, uint64 maxDepth) view returns((string,string,uint64,bool,bool)[] entries)
+func (_VmSafe *VmSafeCaller) ReadDir(opts *bind.CallOpts, path string, maxDepth uint64) ([]VmSafeDirEntry, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "readDir", path, maxDepth)
+
+	if err != nil {
+		return *new([]VmSafeDirEntry), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]VmSafeDirEntry)).(*[]VmSafeDirEntry)
+
+	return out0, err
+
+}
+
+// ReadDir is a free data retrieval call binding the contract method 0x1497876c.
+//
+// Solidity: function readDir(string path, uint64 maxDepth) view returns((string,string,uint64,bool,bool)[] entries)
+func (_VmSafe *VmSafeSession) ReadDir(path string, maxDepth uint64) ([]VmSafeDirEntry, error) {
+	return _VmSafe.Contract.ReadDir(&_VmSafe.CallOpts, path, maxDepth)
+}
+
+// ReadDir is a free data retrieval call binding the contract method 0x1497876c.
+//
+// Solidity: function readDir(string path, uint64 maxDepth) view returns((string,string,uint64,bool,bool)[] entries)
+func (_VmSafe *VmSafeCallerSession) ReadDir(path string, maxDepth uint64) ([]VmSafeDirEntry, error) {
+	return _VmSafe.Contract.ReadDir(&_VmSafe.CallOpts, path, maxDepth)
+}
+
+// ReadDir0 is a free data retrieval call binding the contract method 0x8102d70d.
+//
+// Solidity: function readDir(string path, uint64 maxDepth, bool followLinks) view returns((string,string,uint64,bool,bool)[] entries)
+func (_VmSafe *VmSafeCaller) ReadDir0(opts *bind.CallOpts, path string, maxDepth uint64, followLinks bool) ([]VmSafeDirEntry, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "readDir0", path, maxDepth, followLinks)
+
+	if err != nil {
+		return *new([]VmSafeDirEntry), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]VmSafeDirEntry)).(*[]VmSafeDirEntry)
+
+	return out0, err
+
+}
+
+// ReadDir0 is a free data retrieval call binding the contract method 0x8102d70d.
+//
+// Solidity: function readDir(string path, uint64 maxDepth, bool followLinks) view returns((string,string,uint64,bool,bool)[] entries)
+func (_VmSafe *VmSafeSession) ReadDir0(path string, maxDepth uint64, followLinks bool) ([]VmSafeDirEntry, error) {
+	return _VmSafe.Contract.ReadDir0(&_VmSafe.CallOpts, path, maxDepth, followLinks)
+}
+
+// ReadDir0 is a free data retrieval call binding the contract method 0x8102d70d.
+//
+// Solidity: function readDir(string path, uint64 maxDepth, bool followLinks) view returns((string,string,uint64,bool,bool)[] entries)
+func (_VmSafe *VmSafeCallerSession) ReadDir0(path string, maxDepth uint64, followLinks bool) ([]VmSafeDirEntry, error) {
+	return _VmSafe.Contract.ReadDir0(&_VmSafe.CallOpts, path, maxDepth, followLinks)
+}
+
+// ReadDir1 is a free data retrieval call binding the contract method 0xc4bc59e0.
+//
+// Solidity: function readDir(string path) view returns((string,string,uint64,bool,bool)[] entries)
+func (_VmSafe *VmSafeCaller) ReadDir1(opts *bind.CallOpts, path string) ([]VmSafeDirEntry, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "readDir1", path)
+
+	if err != nil {
+		return *new([]VmSafeDirEntry), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]VmSafeDirEntry)).(*[]VmSafeDirEntry)
+
+	return out0, err
+
+}
+
+// ReadDir1 is a free data retrieval call binding the contract method 0xc4bc59e0.
+//
+// Solidity: function readDir(string path) view returns((string,string,uint64,bool,bool)[] entries)
+func (_VmSafe *VmSafeSession) ReadDir1(path string) ([]VmSafeDirEntry, error) {
+	return _VmSafe.Contract.ReadDir1(&_VmSafe.CallOpts, path)
+}
+
+// ReadDir1 is a free data retrieval call binding the contract method 0xc4bc59e0.
+//
+// Solidity: function readDir(string path) view returns((string,string,uint64,bool,bool)[] entries)
+func (_VmSafe *VmSafeCallerSession) ReadDir1(path string) ([]VmSafeDirEntry, error) {
+	return _VmSafe.Contract.ReadDir1(&_VmSafe.CallOpts, path)
+}
+
+// ReadFile is a free data retrieval call binding the contract method 0x60f9bb11.
+//
+// Solidity: function readFile(string path) view returns(string data)
+func (_VmSafe *VmSafeCaller) ReadFile(opts *bind.CallOpts, path string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "readFile", path)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ReadFile is a free data retrieval call binding the contract method 0x60f9bb11.
+//
+// Solidity: function readFile(string path) view returns(string data)
+func (_VmSafe *VmSafeSession) ReadFile(path string) (string, error) {
+	return _VmSafe.Contract.ReadFile(&_VmSafe.CallOpts, path)
+}
+
+// ReadFile is a free data retrieval call binding the contract method 0x60f9bb11.
+//
+// Solidity: function readFile(string path) view returns(string data)
+func (_VmSafe *VmSafeCallerSession) ReadFile(path string) (string, error) {
+	return _VmSafe.Contract.ReadFile(&_VmSafe.CallOpts, path)
+}
+
+// ReadFileBinary is a free data retrieval call binding the contract method 0x16ed7bc4.
+//
+// Solidity: function readFileBinary(string path) view returns(bytes data)
+func (_VmSafe *VmSafeCaller) ReadFileBinary(opts *bind.CallOpts, path string) ([]byte, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "readFileBinary", path)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ReadFileBinary is a free data retrieval call binding the contract method 0x16ed7bc4.
+//
+// Solidity: function readFileBinary(string path) view returns(bytes data)
+func (_VmSafe *VmSafeSession) ReadFileBinary(path string) ([]byte, error) {
+	return _VmSafe.Contract.ReadFileBinary(&_VmSafe.CallOpts, path)
+}
+
+// ReadFileBinary is a free data retrieval call binding the contract method 0x16ed7bc4.
+//
+// Solidity: function readFileBinary(string path) view returns(bytes data)
+func (_VmSafe *VmSafeCallerSession) ReadFileBinary(path string) ([]byte, error) {
+	return _VmSafe.Contract.ReadFileBinary(&_VmSafe.CallOpts, path)
+}
+
+// ReadLine is a free data retrieval call binding the contract method 0x70f55728.
+//
+// Solidity: function readLine(string path) view returns(string line)
+func (_VmSafe *VmSafeCaller) ReadLine(opts *bind.CallOpts, path string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "readLine", path)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ReadLine is a free data retrieval call binding the contract method 0x70f55728.
+//
+// Solidity: function readLine(string path) view returns(string line)
+func (_VmSafe *VmSafeSession) ReadLine(path string) (string, error) {
+	return _VmSafe.Contract.ReadLine(&_VmSafe.CallOpts, path)
+}
+
+// ReadLine is a free data retrieval call binding the contract method 0x70f55728.
+//
+// Solidity: function readLine(string path) view returns(string line)
+func (_VmSafe *VmSafeCallerSession) ReadLine(path string) (string, error) {
+	return _VmSafe.Contract.ReadLine(&_VmSafe.CallOpts, path)
+}
+
+// ReadLink is a free data retrieval call binding the contract method 0x9f5684a2.
+//
+// Solidity: function readLink(string linkPath) view returns(string targetPath)
+func (_VmSafe *VmSafeCaller) ReadLink(opts *bind.CallOpts, linkPath string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "readLink", linkPath)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ReadLink is a free data retrieval call binding the contract method 0x9f5684a2.
+//
+// Solidity: function readLink(string linkPath) view returns(string targetPath)
+func (_VmSafe *VmSafeSession) ReadLink(linkPath string) (string, error) {
+	return _VmSafe.Contract.ReadLink(&_VmSafe.CallOpts, linkPath)
+}
+
+// ReadLink is a free data retrieval call binding the contract method 0x9f5684a2.
+//
+// Solidity: function readLink(string linkPath) view returns(string targetPath)
+func (_VmSafe *VmSafeCallerSession) ReadLink(linkPath string) (string, error) {
+	return _VmSafe.Contract.ReadLink(&_VmSafe.CallOpts, linkPath)
+}
+
+// Replace is a free data retrieval call binding the contract method 0xe00ad03e.
+//
+// Solidity: function replace(string input, string from, string to) pure returns(string output)
+func (_VmSafe *VmSafeCaller) Replace(opts *bind.CallOpts, input string, from string, to string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "replace", input, from, to)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// Replace is a free data retrieval call binding the contract method 0xe00ad03e.
+//
+// Solidity: function replace(string input, string from, string to) pure returns(string output)
+func (_VmSafe *VmSafeSession) Replace(input string, from string, to string) (string, error) {
+	return _VmSafe.Contract.Replace(&_VmSafe.CallOpts, input, from, to)
+}
+
+// Replace is a free data retrieval call binding the contract method 0xe00ad03e.
+//
+// Solidity: function replace(string input, string from, string to) pure returns(string output)
+func (_VmSafe *VmSafeCallerSession) Replace(input string, from string, to string) (string, error) {
+	return _VmSafe.Contract.Replace(&_VmSafe.CallOpts, input, from, to)
+}
+
+// ResumeTracing is a free data retrieval call binding the contract method 0x72a09ccb.
+//
+// Solidity: function resumeTracing() view returns()
+func (_VmSafe *VmSafeCaller) ResumeTracing(opts *bind.CallOpts) error {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "resumeTracing")
+
+	if err != nil {
+		return err
+	}
+
+	return err
+
+}
+
+// ResumeTracing is a free data retrieval call binding the contract method 0x72a09ccb.
+//
+// Solidity: function resumeTracing() view returns()
+func (_VmSafe *VmSafeSession) ResumeTracing() error {
+	return _VmSafe.Contract.ResumeTracing(&_VmSafe.CallOpts)
+}
+
+// ResumeTracing is a free data retrieval call binding the contract method 0x72a09ccb.
+//
+// Solidity: function resumeTracing() view returns()
+func (_VmSafe *VmSafeCallerSession) ResumeTracing() error {
+	return _VmSafe.Contract.ResumeTracing(&_VmSafe.CallOpts)
+}
+
+// RpcUrl is a free data retrieval call binding the contract method 0x975a6ce9.
+//
+// Solidity: function rpcUrl(string rpcAlias) view returns(string json)
+func (_VmSafe *VmSafeCaller) RpcUrl(opts *bind.CallOpts, rpcAlias string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "rpcUrl", rpcAlias)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// RpcUrl is a free data retrieval call binding the contract method 0x975a6ce9.
+//
+// Solidity: function rpcUrl(string rpcAlias) view returns(string json)
+func (_VmSafe *VmSafeSession) RpcUrl(rpcAlias string) (string, error) {
+	return _VmSafe.Contract.RpcUrl(&_VmSafe.CallOpts, rpcAlias)
+}
+
+// RpcUrl is a free data retrieval call binding the contract method 0x975a6ce9.
+//
+// Solidity: function rpcUrl(string rpcAlias) view returns(string json)
+func (_VmSafe *VmSafeCallerSession) RpcUrl(rpcAlias string) (string, error) {
+	return _VmSafe.Contract.RpcUrl(&_VmSafe.CallOpts, rpcAlias)
+}
+
+// RpcUrlStructs is a free data retrieval call binding the contract method 0x9d2ad72a.
+//
+// Solidity: function rpcUrlStructs() view returns((string,string)[] urls)
+func (_VmSafe *VmSafeCaller) RpcUrlStructs(opts *bind.CallOpts) ([]VmSafeRpc, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "rpcUrlStructs")
+
+	if err != nil {
+		return *new([]VmSafeRpc), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]VmSafeRpc)).(*[]VmSafeRpc)
+
+	return out0, err
+
+}
+
+// RpcUrlStructs is a free data retrieval call binding the contract method 0x9d2ad72a.
+//
+// Solidity: function rpcUrlStructs() view returns((string,string)[] urls)
+func (_VmSafe *VmSafeSession) RpcUrlStructs() ([]VmSafeRpc, error) {
+	return _VmSafe.Contract.RpcUrlStructs(&_VmSafe.CallOpts)
+}
+
+// RpcUrlStructs is a free data retrieval call binding the contract method 0x9d2ad72a.
+//
+// Solidity: function rpcUrlStructs() view returns((string,string)[] urls)
+func (_VmSafe *VmSafeCallerSession) RpcUrlStructs() ([]VmSafeRpc, error) {
+	return _VmSafe.Contract.RpcUrlStructs(&_VmSafe.CallOpts)
+}
+
+// RpcUrls is a free data retrieval call binding the contract method 0xa85a8418.
+//
+// Solidity: function rpcUrls() view returns(string[2][] urls)
+func (_VmSafe *VmSafeCaller) RpcUrls(opts *bind.CallOpts) ([][2]string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "rpcUrls")
+
+	if err != nil {
+		return *new([][2]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][2]string)).(*[][2]string)
+
+	return out0, err
+
+}
+
+// RpcUrls is a free data retrieval call binding the contract method 0xa85a8418.
+//
+// Solidity: function rpcUrls() view returns(string[2][] urls)
+func (_VmSafe *VmSafeSession) RpcUrls() ([][2]string, error) {
+	return _VmSafe.Contract.RpcUrls(&_VmSafe.CallOpts)
+}
+
+// RpcUrls is a free data retrieval call binding the contract method 0xa85a8418.
+//
+// Solidity: function rpcUrls() view returns(string[2][] urls)
+func (_VmSafe *VmSafeCallerSession) RpcUrls() ([][2]string, error) {
+	return _VmSafe.Contract.RpcUrls(&_VmSafe.CallOpts)
+}
+
+// SerializeJsonType is a free data retrieval call binding the contract method 0x6d4f96a6.
+//
+// Solidity: function serializeJsonType(string typeDescription, bytes value) pure returns(string json)
+func (_VmSafe *VmSafeCaller) SerializeJsonType(opts *bind.CallOpts, typeDescription string, value []byte) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "serializeJsonType", typeDescription, value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// SerializeJsonType is a free data retrieval call binding the contract method 0x6d4f96a6.
+//
+// Solidity: function serializeJsonType(string typeDescription, bytes value) pure returns(string json)
+func (_VmSafe *VmSafeSession) SerializeJsonType(typeDescription string, value []byte) (string, error) {
+	return _VmSafe.Contract.SerializeJsonType(&_VmSafe.CallOpts, typeDescription, value)
+}
+
+// SerializeJsonType is a free data retrieval call binding the contract method 0x6d4f96a6.
+//
+// Solidity: function serializeJsonType(string typeDescription, bytes value) pure returns(string json)
+func (_VmSafe *VmSafeCallerSession) SerializeJsonType(typeDescription string, value []byte) (string, error) {
+	return _VmSafe.Contract.SerializeJsonType(&_VmSafe.CallOpts, typeDescription, value)
+}
+
+// Sign is a free data retrieval call binding the contract method 0x799cd333.
+//
+// Solidity: function sign(bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeCaller) Sign(opts *bind.CallOpts, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "sign", digest)
+
+	outstruct := new(struct {
+		V uint8
+		R [32]byte
+		S [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.V = *abi.ConvertType(out[0], new(uint8)).(*uint8)
+	outstruct.R = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+	outstruct.S = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// Sign is a free data retrieval call binding the contract method 0x799cd333.
+//
+// Solidity: function sign(bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeSession) Sign(digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _VmSafe.Contract.Sign(&_VmSafe.CallOpts, digest)
+}
+
+// Sign is a free data retrieval call binding the contract method 0x799cd333.
+//
+// Solidity: function sign(bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeCallerSession) Sign(digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _VmSafe.Contract.Sign(&_VmSafe.CallOpts, digest)
+}
+
+// Sign0 is a free data retrieval call binding the contract method 0x8c1aa205.
+//
+// Solidity: function sign(address signer, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeCaller) Sign0(opts *bind.CallOpts, signer common.Address, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "sign0", signer, digest)
+
+	outstruct := new(struct {
+		V uint8
+		R [32]byte
+		S [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.V = *abi.ConvertType(out[0], new(uint8)).(*uint8)
+	outstruct.R = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+	outstruct.S = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// Sign0 is a free data retrieval call binding the contract method 0x8c1aa205.
+//
+// Solidity: function sign(address signer, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeSession) Sign0(signer common.Address, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _VmSafe.Contract.Sign0(&_VmSafe.CallOpts, signer, digest)
+}
+
+// Sign0 is a free data retrieval call binding the contract method 0x8c1aa205.
+//
+// Solidity: function sign(address signer, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeCallerSession) Sign0(signer common.Address, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _VmSafe.Contract.Sign0(&_VmSafe.CallOpts, signer, digest)
+}
+
+// Sign2 is a free data retrieval call binding the contract method 0xe341eaa4.
+//
+// Solidity: function sign(uint256 privateKey, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeCaller) Sign2(opts *bind.CallOpts, privateKey *big.Int, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "sign2", privateKey, digest)
+
+	outstruct := new(struct {
+		V uint8
+		R [32]byte
+		S [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.V = *abi.ConvertType(out[0], new(uint8)).(*uint8)
+	outstruct.R = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+	outstruct.S = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// Sign2 is a free data retrieval call binding the contract method 0xe341eaa4.
+//
+// Solidity: function sign(uint256 privateKey, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeSession) Sign2(privateKey *big.Int, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _VmSafe.Contract.Sign2(&_VmSafe.CallOpts, privateKey, digest)
+}
+
+// Sign2 is a free data retrieval call binding the contract method 0xe341eaa4.
+//
+// Solidity: function sign(uint256 privateKey, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeCallerSession) Sign2(privateKey *big.Int, digest [32]byte) (struct {
+	V uint8
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _VmSafe.Contract.Sign2(&_VmSafe.CallOpts, privateKey, digest)
+}
+
+// SignCompact0 is a free data retrieval call binding the contract method 0x8e2f97bf.
+//
+// Solidity: function signCompact(address signer, bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_VmSafe *VmSafeCaller) SignCompact0(opts *bind.CallOpts, signer common.Address, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "signCompact0", signer, digest)
+
+	outstruct := new(struct {
+		R  [32]byte
+		Vs [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.R = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+	outstruct.Vs = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// SignCompact0 is a free data retrieval call binding the contract method 0x8e2f97bf.
+//
+// Solidity: function signCompact(address signer, bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_VmSafe *VmSafeSession) SignCompact0(signer common.Address, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	return _VmSafe.Contract.SignCompact0(&_VmSafe.CallOpts, signer, digest)
+}
+
+// SignCompact0 is a free data retrieval call binding the contract method 0x8e2f97bf.
+//
+// Solidity: function signCompact(address signer, bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_VmSafe *VmSafeCallerSession) SignCompact0(signer common.Address, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	return _VmSafe.Contract.SignCompact0(&_VmSafe.CallOpts, signer, digest)
+}
+
+// SignCompact1 is a free data retrieval call binding the contract method 0xa282dc4b.
+//
+// Solidity: function signCompact(bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_VmSafe *VmSafeCaller) SignCompact1(opts *bind.CallOpts, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "signCompact1", digest)
+
+	outstruct := new(struct {
+		R  [32]byte
+		Vs [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.R = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+	outstruct.Vs = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// SignCompact1 is a free data retrieval call binding the contract method 0xa282dc4b.
+//
+// Solidity: function signCompact(bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_VmSafe *VmSafeSession) SignCompact1(digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	return _VmSafe.Contract.SignCompact1(&_VmSafe.CallOpts, digest)
+}
+
+// SignCompact1 is a free data retrieval call binding the contract method 0xa282dc4b.
+//
+// Solidity: function signCompact(bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_VmSafe *VmSafeCallerSession) SignCompact1(digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	return _VmSafe.Contract.SignCompact1(&_VmSafe.CallOpts, digest)
+}
+
+// SignCompact2 is a free data retrieval call binding the contract method 0xcc2a781f.
+//
+// Solidity: function signCompact(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_VmSafe *VmSafeCaller) SignCompact2(opts *bind.CallOpts, privateKey *big.Int, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "signCompact2", privateKey, digest)
+
+	outstruct := new(struct {
+		R  [32]byte
+		Vs [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.R = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+	outstruct.Vs = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// SignCompact2 is a free data retrieval call binding the contract method 0xcc2a781f.
+//
+// Solidity: function signCompact(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_VmSafe *VmSafeSession) SignCompact2(privateKey *big.Int, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	return _VmSafe.Contract.SignCompact2(&_VmSafe.CallOpts, privateKey, digest)
+}
+
+// SignCompact2 is a free data retrieval call binding the contract method 0xcc2a781f.
+//
+// Solidity: function signCompact(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 vs)
+func (_VmSafe *VmSafeCallerSession) SignCompact2(privateKey *big.Int, digest [32]byte) (struct {
+	R  [32]byte
+	Vs [32]byte
+}, error) {
+	return _VmSafe.Contract.SignCompact2(&_VmSafe.CallOpts, privateKey, digest)
+}
+
+// SignP256 is a free data retrieval call binding the contract method 0x83211b40.
+//
+// Solidity: function signP256(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeCaller) SignP256(opts *bind.CallOpts, privateKey *big.Int, digest [32]byte) (struct {
+	R [32]byte
+	S [32]byte
+}, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "signP256", privateKey, digest)
+
+	outstruct := new(struct {
+		R [32]byte
+		S [32]byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.R = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+	outstruct.S = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
+
+	return *outstruct, err
+
+}
+
+// SignP256 is a free data retrieval call binding the contract method 0x83211b40.
+//
+// Solidity: function signP256(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeSession) SignP256(privateKey *big.Int, digest [32]byte) (struct {
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _VmSafe.Contract.SignP256(&_VmSafe.CallOpts, privateKey, digest)
+}
+
+// SignP256 is a free data retrieval call binding the contract method 0x83211b40.
+//
+// Solidity: function signP256(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeCallerSession) SignP256(privateKey *big.Int, digest [32]byte) (struct {
+	R [32]byte
+	S [32]byte
+}, error) {
+	return _VmSafe.Contract.SignP256(&_VmSafe.CallOpts, privateKey, digest)
+}
+
+// Split is a free data retrieval call binding the contract method 0x8bb75533.
+//
+// Solidity: function split(string input, string delimiter) pure returns(string[] outputs)
+func (_VmSafe *VmSafeCaller) Split(opts *bind.CallOpts, input string, delimiter string) ([]string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "split", input, delimiter)
+
+	if err != nil {
+		return *new([]string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]string)).(*[]string)
+
+	return out0, err
+
+}
+
+// Split is a free data retrieval call binding the contract method 0x8bb75533.
+//
+// Solidity: function split(string input, string delimiter) pure returns(string[] outputs)
+func (_VmSafe *VmSafeSession) Split(input string, delimiter string) ([]string, error) {
+	return _VmSafe.Contract.Split(&_VmSafe.CallOpts, input, delimiter)
+}
+
+// Split is a free data retrieval call binding the contract method 0x8bb75533.
+//
+// Solidity: function split(string input, string delimiter) pure returns(string[] outputs)
+func (_VmSafe *VmSafeCallerSession) Split(input string, delimiter string) ([]string, error) {
+	return _VmSafe.Contract.Split(&_VmSafe.CallOpts, input, delimiter)
+}
+
+// ToBase64 is a free data retrieval call binding the contract method 0x3f8be2c8.
+//
+// Solidity: function toBase64(string data) pure returns(string)
+func (_VmSafe *VmSafeCaller) ToBase64(opts *bind.CallOpts, data string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "toBase64", data)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToBase64 is a free data retrieval call binding the contract method 0x3f8be2c8.
+//
+// Solidity: function toBase64(string data) pure returns(string)
+func (_VmSafe *VmSafeSession) ToBase64(data string) (string, error) {
+	return _VmSafe.Contract.ToBase64(&_VmSafe.CallOpts, data)
+}
+
+// ToBase64 is a free data retrieval call binding the contract method 0x3f8be2c8.
+//
+// Solidity: function toBase64(string data) pure returns(string)
+func (_VmSafe *VmSafeCallerSession) ToBase64(data string) (string, error) {
+	return _VmSafe.Contract.ToBase64(&_VmSafe.CallOpts, data)
+}
+
+// ToBase640 is a free data retrieval call binding the contract method 0xa5cbfe65.
+//
+// Solidity: function toBase64(bytes data) pure returns(string)
+func (_VmSafe *VmSafeCaller) ToBase640(opts *bind.CallOpts, data []byte) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "toBase640", data)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToBase640 is a free data retrieval call binding the contract method 0xa5cbfe65.
+//
+// Solidity: function toBase64(bytes data) pure returns(string)
+func (_VmSafe *VmSafeSession) ToBase640(data []byte) (string, error) {
+	return _VmSafe.Contract.ToBase640(&_VmSafe.CallOpts, data)
+}
+
+// ToBase640 is a free data retrieval call binding the contract method 0xa5cbfe65.
+//
+// Solidity: function toBase64(bytes data) pure returns(string)
+func (_VmSafe *VmSafeCallerSession) ToBase640(data []byte) (string, error) {
+	return _VmSafe.Contract.ToBase640(&_VmSafe.CallOpts, data)
+}
+
+// ToBase64URL is a free data retrieval call binding the contract method 0xae3165b3.
+//
+// Solidity: function toBase64URL(string data) pure returns(string)
+func (_VmSafe *VmSafeCaller) ToBase64URL(opts *bind.CallOpts, data string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "toBase64URL", data)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToBase64URL is a free data retrieval call binding the contract method 0xae3165b3.
+//
+// Solidity: function toBase64URL(string data) pure returns(string)
+func (_VmSafe *VmSafeSession) ToBase64URL(data string) (string, error) {
+	return _VmSafe.Contract.ToBase64URL(&_VmSafe.CallOpts, data)
+}
+
+// ToBase64URL is a free data retrieval call binding the contract method 0xae3165b3.
+//
+// Solidity: function toBase64URL(string data) pure returns(string)
+func (_VmSafe *VmSafeCallerSession) ToBase64URL(data string) (string, error) {
+	return _VmSafe.Contract.ToBase64URL(&_VmSafe.CallOpts, data)
+}
+
+// ToBase64URL0 is a free data retrieval call binding the contract method 0xc8bd0e4a.
+//
+// Solidity: function toBase64URL(bytes data) pure returns(string)
+func (_VmSafe *VmSafeCaller) ToBase64URL0(opts *bind.CallOpts, data []byte) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "toBase64URL0", data)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToBase64URL0 is a free data retrieval call binding the contract method 0xc8bd0e4a.
+//
+// Solidity: function toBase64URL(bytes data) pure returns(string)
+func (_VmSafe *VmSafeSession) ToBase64URL0(data []byte) (string, error) {
+	return _VmSafe.Contract.ToBase64URL0(&_VmSafe.CallOpts, data)
+}
+
+// ToBase64URL0 is a free data retrieval call binding the contract method 0xc8bd0e4a.
+//
+// Solidity: function toBase64URL(bytes data) pure returns(string)
+func (_VmSafe *VmSafeCallerSession) ToBase64URL0(data []byte) (string, error) {
+	return _VmSafe.Contract.ToBase64URL0(&_VmSafe.CallOpts, data)
+}
+
+// ToLowercase is a free data retrieval call binding the contract method 0x50bb0884.
+//
+// Solidity: function toLowercase(string input) pure returns(string output)
+func (_VmSafe *VmSafeCaller) ToLowercase(opts *bind.CallOpts, input string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "toLowercase", input)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToLowercase is a free data retrieval call binding the contract method 0x50bb0884.
+//
+// Solidity: function toLowercase(string input) pure returns(string output)
+func (_VmSafe *VmSafeSession) ToLowercase(input string) (string, error) {
+	return _VmSafe.Contract.ToLowercase(&_VmSafe.CallOpts, input)
+}
+
+// ToLowercase is a free data retrieval call binding the contract method 0x50bb0884.
+//
+// Solidity: function toLowercase(string input) pure returns(string output)
+func (_VmSafe *VmSafeCallerSession) ToLowercase(input string) (string, error) {
+	return _VmSafe.Contract.ToLowercase(&_VmSafe.CallOpts, input)
+}
+
+// ToString is a free data retrieval call binding the contract method 0x56ca623e.
+//
+// Solidity: function toString(address value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeCaller) ToString(opts *bind.CallOpts, value common.Address) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "toString", value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToString is a free data retrieval call binding the contract method 0x56ca623e.
+//
+// Solidity: function toString(address value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeSession) ToString(value common.Address) (string, error) {
+	return _VmSafe.Contract.ToString(&_VmSafe.CallOpts, value)
+}
+
+// ToString is a free data retrieval call binding the contract method 0x56ca623e.
+//
+// Solidity: function toString(address value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeCallerSession) ToString(value common.Address) (string, error) {
+	return _VmSafe.Contract.ToString(&_VmSafe.CallOpts, value)
+}
+
+// ToString0 is a free data retrieval call binding the contract method 0x6900a3ae.
+//
+// Solidity: function toString(uint256 value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeCaller) ToString0(opts *bind.CallOpts, value *big.Int) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "toString0", value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToString0 is a free data retrieval call binding the contract method 0x6900a3ae.
+//
+// Solidity: function toString(uint256 value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeSession) ToString0(value *big.Int) (string, error) {
+	return _VmSafe.Contract.ToString0(&_VmSafe.CallOpts, value)
+}
+
+// ToString0 is a free data retrieval call binding the contract method 0x6900a3ae.
+//
+// Solidity: function toString(uint256 value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeCallerSession) ToString0(value *big.Int) (string, error) {
+	return _VmSafe.Contract.ToString0(&_VmSafe.CallOpts, value)
+}
+
+// ToString1 is a free data retrieval call binding the contract method 0x71aad10d.
+//
+// Solidity: function toString(bytes value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeCaller) ToString1(opts *bind.CallOpts, value []byte) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "toString1", value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToString1 is a free data retrieval call binding the contract method 0x71aad10d.
+//
+// Solidity: function toString(bytes value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeSession) ToString1(value []byte) (string, error) {
+	return _VmSafe.Contract.ToString1(&_VmSafe.CallOpts, value)
+}
+
+// ToString1 is a free data retrieval call binding the contract method 0x71aad10d.
+//
+// Solidity: function toString(bytes value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeCallerSession) ToString1(value []byte) (string, error) {
+	return _VmSafe.Contract.ToString1(&_VmSafe.CallOpts, value)
+}
+
+// ToString2 is a free data retrieval call binding the contract method 0x71dce7da.
+//
+// Solidity: function toString(bool value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeCaller) ToString2(opts *bind.CallOpts, value bool) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "toString2", value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToString2 is a free data retrieval call binding the contract method 0x71dce7da.
+//
+// Solidity: function toString(bool value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeSession) ToString2(value bool) (string, error) {
+	return _VmSafe.Contract.ToString2(&_VmSafe.CallOpts, value)
+}
+
+// ToString2 is a free data retrieval call binding the contract method 0x71dce7da.
+//
+// Solidity: function toString(bool value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeCallerSession) ToString2(value bool) (string, error) {
+	return _VmSafe.Contract.ToString2(&_VmSafe.CallOpts, value)
+}
+
+// ToString3 is a free data retrieval call binding the contract method 0xa322c40e.
+//
+// Solidity: function toString(int256 value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeCaller) ToString3(opts *bind.CallOpts, value *big.Int) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "toString3", value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToString3 is a free data retrieval call binding the contract method 0xa322c40e.
+//
+// Solidity: function toString(int256 value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeSession) ToString3(value *big.Int) (string, error) {
+	return _VmSafe.Contract.ToString3(&_VmSafe.CallOpts, value)
+}
+
+// ToString3 is a free data retrieval call binding the contract method 0xa322c40e.
+//
+// Solidity: function toString(int256 value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeCallerSession) ToString3(value *big.Int) (string, error) {
+	return _VmSafe.Contract.ToString3(&_VmSafe.CallOpts, value)
+}
+
+// ToString4 is a free data retrieval call binding the contract method 0xb11a19e8.
+//
+// Solidity: function toString(bytes32 value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeCaller) ToString4(opts *bind.CallOpts, value [32]byte) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "toString4", value)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToString4 is a free data retrieval call binding the contract method 0xb11a19e8.
+//
+// Solidity: function toString(bytes32 value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeSession) ToString4(value [32]byte) (string, error) {
+	return _VmSafe.Contract.ToString4(&_VmSafe.CallOpts, value)
+}
+
+// ToString4 is a free data retrieval call binding the contract method 0xb11a19e8.
+//
+// Solidity: function toString(bytes32 value) pure returns(string stringifiedValue)
+func (_VmSafe *VmSafeCallerSession) ToString4(value [32]byte) (string, error) {
+	return _VmSafe.Contract.ToString4(&_VmSafe.CallOpts, value)
+}
+
+// ToUppercase is a free data retrieval call binding the contract method 0x074ae3d7.
+//
+// Solidity: function toUppercase(string input) pure returns(string output)
+func (_VmSafe *VmSafeCaller) ToUppercase(opts *bind.CallOpts, input string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "toUppercase", input)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// ToUppercase is a free data retrieval call binding the contract method 0x074ae3d7.
+//
+// Solidity: function toUppercase(string input) pure returns(string output)
+func (_VmSafe *VmSafeSession) ToUppercase(input string) (string, error) {
+	return _VmSafe.Contract.ToUppercase(&_VmSafe.CallOpts, input)
+}
+
+// ToUppercase is a free data retrieval call binding the contract method 0x074ae3d7.
+//
+// Solidity: function toUppercase(string input) pure returns(string output)
+func (_VmSafe *VmSafeCallerSession) ToUppercase(input string) (string, error) {
+	return _VmSafe.Contract.ToUppercase(&_VmSafe.CallOpts, input)
+}
+
+// Trim is a free data retrieval call binding the contract method 0xb2dad155.
+//
+// Solidity: function trim(string input) pure returns(string output)
+func (_VmSafe *VmSafeCaller) Trim(opts *bind.CallOpts, input string) (string, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "trim", input)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// Trim is a free data retrieval call binding the contract method 0xb2dad155.
+//
+// Solidity: function trim(string input) pure returns(string output)
+func (_VmSafe *VmSafeSession) Trim(input string) (string, error) {
+	return _VmSafe.Contract.Trim(&_VmSafe.CallOpts, input)
+}
+
+// Trim is a free data retrieval call binding the contract method 0xb2dad155.
+//
+// Solidity: function trim(string input) pure returns(string output)
+func (_VmSafe *VmSafeCallerSession) Trim(input string) (string, error) {
+	return _VmSafe.Contract.Trim(&_VmSafe.CallOpts, input)
+}
+
+// UnixTime is a free data retrieval call binding the contract method 0x625387dc.
+//
+// Solidity: function unixTime() view returns(uint256 milliseconds)
+func (_VmSafe *VmSafeCaller) UnixTime(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _VmSafe.contract.Call(opts, &out, "unixTime")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// UnixTime is a free data retrieval call binding the contract method 0x625387dc.
+//
+// Solidity: function unixTime() view returns(uint256 milliseconds)
+func (_VmSafe *VmSafeSession) UnixTime() (*big.Int, error) {
+	return _VmSafe.Contract.UnixTime(&_VmSafe.CallOpts)
+}
+
+// UnixTime is a free data retrieval call binding the contract method 0x625387dc.
+//
+// Solidity: function unixTime() view returns(uint256 milliseconds)
+func (_VmSafe *VmSafeCallerSession) UnixTime() (*big.Int, error) {
+	return _VmSafe.Contract.UnixTime(&_VmSafe.CallOpts)
+}
+
+// Accesses is a paid mutator transaction binding the contract method 0x65bc9481.
+//
+// Solidity: function accesses(address target) returns(bytes32[] readSlots, bytes32[] writeSlots)
+func (_VmSafe *VmSafeTransactor) Accesses(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "accesses", target)
+}
+
+// Accesses is a paid mutator transaction binding the contract method 0x65bc9481.
+//
+// Solidity: function accesses(address target) returns(bytes32[] readSlots, bytes32[] writeSlots)
+func (_VmSafe *VmSafeSession) Accesses(target common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.Accesses(&_VmSafe.TransactOpts, target)
+}
+
+// Accesses is a paid mutator transaction binding the contract method 0x65bc9481.
+//
+// Solidity: function accesses(address target) returns(bytes32[] readSlots, bytes32[] writeSlots)
+func (_VmSafe *VmSafeTransactorSession) Accesses(target common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.Accesses(&_VmSafe.TransactOpts, target)
+}
+
+// AttachDelegation is a paid mutator transaction binding the contract method 0x14ae3519.
+//
+// Solidity: function attachDelegation((uint8,bytes32,bytes32,uint64,address) signedDelegation) returns()
+func (_VmSafe *VmSafeTransactor) AttachDelegation(opts *bind.TransactOpts, signedDelegation VmSafeSignedDelegation) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "attachDelegation", signedDelegation)
+}
+
+// AttachDelegation is a paid mutator transaction binding the contract method 0x14ae3519.
+//
+// Solidity: function attachDelegation((uint8,bytes32,bytes32,uint64,address) signedDelegation) returns()
+func (_VmSafe *VmSafeSession) AttachDelegation(signedDelegation VmSafeSignedDelegation) (*types.Transaction, error) {
+	return _VmSafe.Contract.AttachDelegation(&_VmSafe.TransactOpts, signedDelegation)
+}
+
+// AttachDelegation is a paid mutator transaction binding the contract method 0x14ae3519.
+//
+// Solidity: function attachDelegation((uint8,bytes32,bytes32,uint64,address) signedDelegation) returns()
+func (_VmSafe *VmSafeTransactorSession) AttachDelegation(signedDelegation VmSafeSignedDelegation) (*types.Transaction, error) {
+	return _VmSafe.Contract.AttachDelegation(&_VmSafe.TransactOpts, signedDelegation)
+}
+
+// Broadcast is a paid mutator transaction binding the contract method 0xafc98040.
+//
+// Solidity: function broadcast() returns()
+func (_VmSafe *VmSafeTransactor) Broadcast(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "broadcast")
+}
+
+// Broadcast is a paid mutator transaction binding the contract method 0xafc98040.
+//
+// Solidity: function broadcast() returns()
+func (_VmSafe *VmSafeSession) Broadcast() (*types.Transaction, error) {
+	return _VmSafe.Contract.Broadcast(&_VmSafe.TransactOpts)
+}
+
+// Broadcast is a paid mutator transaction binding the contract method 0xafc98040.
+//
+// Solidity: function broadcast() returns()
+func (_VmSafe *VmSafeTransactorSession) Broadcast() (*types.Transaction, error) {
+	return _VmSafe.Contract.Broadcast(&_VmSafe.TransactOpts)
+}
+
+// Broadcast0 is a paid mutator transaction binding the contract method 0xe6962cdb.
+//
+// Solidity: function broadcast(address signer) returns()
+func (_VmSafe *VmSafeTransactor) Broadcast0(opts *bind.TransactOpts, signer common.Address) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "broadcast0", signer)
+}
+
+// Broadcast0 is a paid mutator transaction binding the contract method 0xe6962cdb.
+//
+// Solidity: function broadcast(address signer) returns()
+func (_VmSafe *VmSafeSession) Broadcast0(signer common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.Broadcast0(&_VmSafe.TransactOpts, signer)
+}
+
+// Broadcast0 is a paid mutator transaction binding the contract method 0xe6962cdb.
+//
+// Solidity: function broadcast(address signer) returns()
+func (_VmSafe *VmSafeTransactorSession) Broadcast0(signer common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.Broadcast0(&_VmSafe.TransactOpts, signer)
+}
+
+// Broadcast1 is a paid mutator transaction binding the contract method 0xf67a965b.
+//
+// Solidity: function broadcast(uint256 privateKey) returns()
+func (_VmSafe *VmSafeTransactor) Broadcast1(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "broadcast1", privateKey)
+}
+
+// Broadcast1 is a paid mutator transaction binding the contract method 0xf67a965b.
+//
+// Solidity: function broadcast(uint256 privateKey) returns()
+func (_VmSafe *VmSafeSession) Broadcast1(privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.Broadcast1(&_VmSafe.TransactOpts, privateKey)
+}
+
+// Broadcast1 is a paid mutator transaction binding the contract method 0xf67a965b.
+//
+// Solidity: function broadcast(uint256 privateKey) returns()
+func (_VmSafe *VmSafeTransactorSession) Broadcast1(privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.Broadcast1(&_VmSafe.TransactOpts, privateKey)
+}
+
+// BroadcastRawTransaction is a paid mutator transaction binding the contract method 0x8c0c72e0.
+//
+// Solidity: function broadcastRawTransaction(bytes data) returns()
+func (_VmSafe *VmSafeTransactor) BroadcastRawTransaction(opts *bind.TransactOpts, data []byte) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "broadcastRawTransaction", data)
+}
+
+// BroadcastRawTransaction is a paid mutator transaction binding the contract method 0x8c0c72e0.
+//
+// Solidity: function broadcastRawTransaction(bytes data) returns()
+func (_VmSafe *VmSafeSession) BroadcastRawTransaction(data []byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.BroadcastRawTransaction(&_VmSafe.TransactOpts, data)
+}
+
+// BroadcastRawTransaction is a paid mutator transaction binding the contract method 0x8c0c72e0.
+//
+// Solidity: function broadcastRawTransaction(bytes data) returns()
+func (_VmSafe *VmSafeTransactorSession) BroadcastRawTransaction(data []byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.BroadcastRawTransaction(&_VmSafe.TransactOpts, data)
+}
+
+// CloseFile is a paid mutator transaction binding the contract method 0x48c3241f.
+//
+// Solidity: function closeFile(string path) returns()
+func (_VmSafe *VmSafeTransactor) CloseFile(opts *bind.TransactOpts, path string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "closeFile", path)
+}
+
+// CloseFile is a paid mutator transaction binding the contract method 0x48c3241f.
+//
+// Solidity: function closeFile(string path) returns()
+func (_VmSafe *VmSafeSession) CloseFile(path string) (*types.Transaction, error) {
+	return _VmSafe.Contract.CloseFile(&_VmSafe.TransactOpts, path)
+}
+
+// CloseFile is a paid mutator transaction binding the contract method 0x48c3241f.
+//
+// Solidity: function closeFile(string path) returns()
+func (_VmSafe *VmSafeTransactorSession) CloseFile(path string) (*types.Transaction, error) {
+	return _VmSafe.Contract.CloseFile(&_VmSafe.TransactOpts, path)
+}
+
+// Contains is a paid mutator transaction binding the contract method 0x3fb18aec.
+//
+// Solidity: function contains(string subject, string search) returns(bool result)
+func (_VmSafe *VmSafeTransactor) Contains(opts *bind.TransactOpts, subject string, search string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "contains", subject, search)
+}
+
+// Contains is a paid mutator transaction binding the contract method 0x3fb18aec.
+//
+// Solidity: function contains(string subject, string search) returns(bool result)
+func (_VmSafe *VmSafeSession) Contains(subject string, search string) (*types.Transaction, error) {
+	return _VmSafe.Contract.Contains(&_VmSafe.TransactOpts, subject, search)
+}
+
+// Contains is a paid mutator transaction binding the contract method 0x3fb18aec.
+//
+// Solidity: function contains(string subject, string search) returns(bool result)
+func (_VmSafe *VmSafeTransactorSession) Contains(subject string, search string) (*types.Transaction, error) {
+	return _VmSafe.Contract.Contains(&_VmSafe.TransactOpts, subject, search)
+}
+
+// CopyFile is a paid mutator transaction binding the contract method 0xa54a87d8.
+//
+// Solidity: function copyFile(string from, string to) returns(uint64 copied)
+func (_VmSafe *VmSafeTransactor) CopyFile(opts *bind.TransactOpts, from string, to string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "copyFile", from, to)
+}
+
+// CopyFile is a paid mutator transaction binding the contract method 0xa54a87d8.
+//
+// Solidity: function copyFile(string from, string to) returns(uint64 copied)
+func (_VmSafe *VmSafeSession) CopyFile(from string, to string) (*types.Transaction, error) {
+	return _VmSafe.Contract.CopyFile(&_VmSafe.TransactOpts, from, to)
+}
+
+// CopyFile is a paid mutator transaction binding the contract method 0xa54a87d8.
+//
+// Solidity: function copyFile(string from, string to) returns(uint64 copied)
+func (_VmSafe *VmSafeTransactorSession) CopyFile(from string, to string) (*types.Transaction, error) {
+	return _VmSafe.Contract.CopyFile(&_VmSafe.TransactOpts, from, to)
+}
+
+// CopyStorage is a paid mutator transaction binding the contract method 0x203dac0d.
+//
+// Solidity: function copyStorage(address from, address to) returns()
+func (_VmSafe *VmSafeTransactor) CopyStorage(opts *bind.TransactOpts, from common.Address, to common.Address) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "copyStorage", from, to)
+}
+
+// CopyStorage is a paid mutator transaction binding the contract method 0x203dac0d.
+//
+// Solidity: function copyStorage(address from, address to) returns()
+func (_VmSafe *VmSafeSession) CopyStorage(from common.Address, to common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.CopyStorage(&_VmSafe.TransactOpts, from, to)
+}
+
+// CopyStorage is a paid mutator transaction binding the contract method 0x203dac0d.
+//
+// Solidity: function copyStorage(address from, address to) returns()
+func (_VmSafe *VmSafeTransactorSession) CopyStorage(from common.Address, to common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.CopyStorage(&_VmSafe.TransactOpts, from, to)
+}
+
+// CreateDir is a paid mutator transaction binding the contract method 0x168b64d3.
+//
+// Solidity: function createDir(string path, bool recursive) returns()
+func (_VmSafe *VmSafeTransactor) CreateDir(opts *bind.TransactOpts, path string, recursive bool) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "createDir", path, recursive)
+}
+
+// CreateDir is a paid mutator transaction binding the contract method 0x168b64d3.
+//
+// Solidity: function createDir(string path, bool recursive) returns()
+func (_VmSafe *VmSafeSession) CreateDir(path string, recursive bool) (*types.Transaction, error) {
+	return _VmSafe.Contract.CreateDir(&_VmSafe.TransactOpts, path, recursive)
+}
+
+// CreateDir is a paid mutator transaction binding the contract method 0x168b64d3.
+//
+// Solidity: function createDir(string path, bool recursive) returns()
+func (_VmSafe *VmSafeTransactorSession) CreateDir(path string, recursive bool) (*types.Transaction, error) {
+	return _VmSafe.Contract.CreateDir(&_VmSafe.TransactOpts, path, recursive)
+}
+
+// CreateWallet is a paid mutator transaction binding the contract method 0x7404f1d2.
+//
+// Solidity: function createWallet(string walletLabel) returns((address,uint256,uint256,uint256) wallet)
+func (_VmSafe *VmSafeTransactor) CreateWallet(opts *bind.TransactOpts, walletLabel string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "createWallet", walletLabel)
+}
+
+// CreateWallet is a paid mutator transaction binding the contract method 0x7404f1d2.
+//
+// Solidity: function createWallet(string walletLabel) returns((address,uint256,uint256,uint256) wallet)
+func (_VmSafe *VmSafeSession) CreateWallet(walletLabel string) (*types.Transaction, error) {
+	return _VmSafe.Contract.CreateWallet(&_VmSafe.TransactOpts, walletLabel)
+}
+
+// CreateWallet is a paid mutator transaction binding the contract method 0x7404f1d2.
+//
+// Solidity: function createWallet(string walletLabel) returns((address,uint256,uint256,uint256) wallet)
+func (_VmSafe *VmSafeTransactorSession) CreateWallet(walletLabel string) (*types.Transaction, error) {
+	return _VmSafe.Contract.CreateWallet(&_VmSafe.TransactOpts, walletLabel)
+}
+
+// CreateWallet0 is a paid mutator transaction binding the contract method 0x7a675bb6.
+//
+// Solidity: function createWallet(uint256 privateKey) returns((address,uint256,uint256,uint256) wallet)
+func (_VmSafe *VmSafeTransactor) CreateWallet0(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "createWallet0", privateKey)
+}
+
+// CreateWallet0 is a paid mutator transaction binding the contract method 0x7a675bb6.
+//
+// Solidity: function createWallet(uint256 privateKey) returns((address,uint256,uint256,uint256) wallet)
+func (_VmSafe *VmSafeSession) CreateWallet0(privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.CreateWallet0(&_VmSafe.TransactOpts, privateKey)
+}
+
+// CreateWallet0 is a paid mutator transaction binding the contract method 0x7a675bb6.
+//
+// Solidity: function createWallet(uint256 privateKey) returns((address,uint256,uint256,uint256) wallet)
+func (_VmSafe *VmSafeTransactorSession) CreateWallet0(privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.CreateWallet0(&_VmSafe.TransactOpts, privateKey)
+}
+
+// CreateWallet1 is a paid mutator transaction binding the contract method 0xed7c5462.
+//
+// Solidity: function createWallet(uint256 privateKey, string walletLabel) returns((address,uint256,uint256,uint256) wallet)
+func (_VmSafe *VmSafeTransactor) CreateWallet1(opts *bind.TransactOpts, privateKey *big.Int, walletLabel string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "createWallet1", privateKey, walletLabel)
+}
+
+// CreateWallet1 is a paid mutator transaction binding the contract method 0xed7c5462.
+//
+// Solidity: function createWallet(uint256 privateKey, string walletLabel) returns((address,uint256,uint256,uint256) wallet)
+func (_VmSafe *VmSafeSession) CreateWallet1(privateKey *big.Int, walletLabel string) (*types.Transaction, error) {
+	return _VmSafe.Contract.CreateWallet1(&_VmSafe.TransactOpts, privateKey, walletLabel)
+}
+
+// CreateWallet1 is a paid mutator transaction binding the contract method 0xed7c5462.
+//
+// Solidity: function createWallet(uint256 privateKey, string walletLabel) returns((address,uint256,uint256,uint256) wallet)
+func (_VmSafe *VmSafeTransactorSession) CreateWallet1(privateKey *big.Int, walletLabel string) (*types.Transaction, error) {
+	return _VmSafe.Contract.CreateWallet1(&_VmSafe.TransactOpts, privateKey, walletLabel)
+}
+
+// DeployCode is a paid mutator transaction binding the contract method 0x29ce9dde.
+//
+// Solidity: function deployCode(string artifactPath, bytes constructorArgs) returns(address deployedAddress)
+func (_VmSafe *VmSafeTransactor) DeployCode(opts *bind.TransactOpts, artifactPath string, constructorArgs []byte) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "deployCode", artifactPath, constructorArgs)
+}
+
+// DeployCode is a paid mutator transaction binding the contract method 0x29ce9dde.
+//
+// Solidity: function deployCode(string artifactPath, bytes constructorArgs) returns(address deployedAddress)
+func (_VmSafe *VmSafeSession) DeployCode(artifactPath string, constructorArgs []byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.DeployCode(&_VmSafe.TransactOpts, artifactPath, constructorArgs)
+}
+
+// DeployCode is a paid mutator transaction binding the contract method 0x29ce9dde.
+//
+// Solidity: function deployCode(string artifactPath, bytes constructorArgs) returns(address deployedAddress)
+func (_VmSafe *VmSafeTransactorSession) DeployCode(artifactPath string, constructorArgs []byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.DeployCode(&_VmSafe.TransactOpts, artifactPath, constructorArgs)
+}
+
+// DeployCode0 is a paid mutator transaction binding the contract method 0x9a8325a0.
+//
+// Solidity: function deployCode(string artifactPath) returns(address deployedAddress)
+func (_VmSafe *VmSafeTransactor) DeployCode0(opts *bind.TransactOpts, artifactPath string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "deployCode0", artifactPath)
+}
+
+// DeployCode0 is a paid mutator transaction binding the contract method 0x9a8325a0.
+//
+// Solidity: function deployCode(string artifactPath) returns(address deployedAddress)
+func (_VmSafe *VmSafeSession) DeployCode0(artifactPath string) (*types.Transaction, error) {
+	return _VmSafe.Contract.DeployCode0(&_VmSafe.TransactOpts, artifactPath)
+}
+
+// DeployCode0 is a paid mutator transaction binding the contract method 0x9a8325a0.
+//
+// Solidity: function deployCode(string artifactPath) returns(address deployedAddress)
+func (_VmSafe *VmSafeTransactorSession) DeployCode0(artifactPath string) (*types.Transaction, error) {
+	return _VmSafe.Contract.DeployCode0(&_VmSafe.TransactOpts, artifactPath)
+}
+
+// EthGetLogs is a paid mutator transaction binding the contract method 0x35e1349b.
+//
+// Solidity: function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] topics) returns((address,bytes32[],bytes,bytes32,uint64,bytes32,uint64,uint256,bool)[] logs)
+func (_VmSafe *VmSafeTransactor) EthGetLogs(opts *bind.TransactOpts, fromBlock *big.Int, toBlock *big.Int, target common.Address, topics [][32]byte) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "eth_getLogs", fromBlock, toBlock, target, topics)
+}
+
+// EthGetLogs is a paid mutator transaction binding the contract method 0x35e1349b.
+//
+// Solidity: function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] topics) returns((address,bytes32[],bytes,bytes32,uint64,bytes32,uint64,uint256,bool)[] logs)
+func (_VmSafe *VmSafeSession) EthGetLogs(fromBlock *big.Int, toBlock *big.Int, target common.Address, topics [][32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.EthGetLogs(&_VmSafe.TransactOpts, fromBlock, toBlock, target, topics)
+}
+
+// EthGetLogs is a paid mutator transaction binding the contract method 0x35e1349b.
+//
+// Solidity: function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] topics) returns((address,bytes32[],bytes,bytes32,uint64,bytes32,uint64,uint256,bool)[] logs)
+func (_VmSafe *VmSafeTransactorSession) EthGetLogs(fromBlock *big.Int, toBlock *big.Int, target common.Address, topics [][32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.EthGetLogs(&_VmSafe.TransactOpts, fromBlock, toBlock, target, topics)
+}
+
+// Ffi is a paid mutator transaction binding the contract method 0x89160467.
+//
+// Solidity: function ffi(string[] commandInput) returns(bytes result)
+func (_VmSafe *VmSafeTransactor) Ffi(opts *bind.TransactOpts, commandInput []string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "ffi", commandInput)
+}
+
+// Ffi is a paid mutator transaction binding the contract method 0x89160467.
+//
+// Solidity: function ffi(string[] commandInput) returns(bytes result)
+func (_VmSafe *VmSafeSession) Ffi(commandInput []string) (*types.Transaction, error) {
+	return _VmSafe.Contract.Ffi(&_VmSafe.TransactOpts, commandInput)
+}
+
+// Ffi is a paid mutator transaction binding the contract method 0x89160467.
+//
+// Solidity: function ffi(string[] commandInput) returns(bytes result)
+func (_VmSafe *VmSafeTransactorSession) Ffi(commandInput []string) (*types.Transaction, error) {
+	return _VmSafe.Contract.Ffi(&_VmSafe.TransactOpts, commandInput)
+}
+
+// GetMappingKeyAndParentOf is a paid mutator transaction binding the contract method 0x876e24e6.
+//
+// Solidity: function getMappingKeyAndParentOf(address target, bytes32 elementSlot) returns(bool found, bytes32 key, bytes32 parent)
+func (_VmSafe *VmSafeTransactor) GetMappingKeyAndParentOf(opts *bind.TransactOpts, target common.Address, elementSlot [32]byte) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "getMappingKeyAndParentOf", target, elementSlot)
+}
+
+// GetMappingKeyAndParentOf is a paid mutator transaction binding the contract method 0x876e24e6.
+//
+// Solidity: function getMappingKeyAndParentOf(address target, bytes32 elementSlot) returns(bool found, bytes32 key, bytes32 parent)
+func (_VmSafe *VmSafeSession) GetMappingKeyAndParentOf(target common.Address, elementSlot [32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.GetMappingKeyAndParentOf(&_VmSafe.TransactOpts, target, elementSlot)
+}
+
+// GetMappingKeyAndParentOf is a paid mutator transaction binding the contract method 0x876e24e6.
+//
+// Solidity: function getMappingKeyAndParentOf(address target, bytes32 elementSlot) returns(bool found, bytes32 key, bytes32 parent)
+func (_VmSafe *VmSafeTransactorSession) GetMappingKeyAndParentOf(target common.Address, elementSlot [32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.GetMappingKeyAndParentOf(&_VmSafe.TransactOpts, target, elementSlot)
+}
+
+// GetMappingLength is a paid mutator transaction binding the contract method 0x2f2fd63f.
+//
+// Solidity: function getMappingLength(address target, bytes32 mappingSlot) returns(uint256 length)
+func (_VmSafe *VmSafeTransactor) GetMappingLength(opts *bind.TransactOpts, target common.Address, mappingSlot [32]byte) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "getMappingLength", target, mappingSlot)
+}
+
+// GetMappingLength is a paid mutator transaction binding the contract method 0x2f2fd63f.
+//
+// Solidity: function getMappingLength(address target, bytes32 mappingSlot) returns(uint256 length)
+func (_VmSafe *VmSafeSession) GetMappingLength(target common.Address, mappingSlot [32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.GetMappingLength(&_VmSafe.TransactOpts, target, mappingSlot)
+}
+
+// GetMappingLength is a paid mutator transaction binding the contract method 0x2f2fd63f.
+//
+// Solidity: function getMappingLength(address target, bytes32 mappingSlot) returns(uint256 length)
+func (_VmSafe *VmSafeTransactorSession) GetMappingLength(target common.Address, mappingSlot [32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.GetMappingLength(&_VmSafe.TransactOpts, target, mappingSlot)
+}
+
+// GetMappingSlotAt is a paid mutator transaction binding the contract method 0xebc73ab4.
+//
+// Solidity: function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) returns(bytes32 value)
+func (_VmSafe *VmSafeTransactor) GetMappingSlotAt(opts *bind.TransactOpts, target common.Address, mappingSlot [32]byte, idx *big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "getMappingSlotAt", target, mappingSlot, idx)
+}
+
+// GetMappingSlotAt is a paid mutator transaction binding the contract method 0xebc73ab4.
+//
+// Solidity: function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) returns(bytes32 value)
+func (_VmSafe *VmSafeSession) GetMappingSlotAt(target common.Address, mappingSlot [32]byte, idx *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.GetMappingSlotAt(&_VmSafe.TransactOpts, target, mappingSlot, idx)
+}
+
+// GetMappingSlotAt is a paid mutator transaction binding the contract method 0xebc73ab4.
+//
+// Solidity: function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) returns(bytes32 value)
+func (_VmSafe *VmSafeTransactorSession) GetMappingSlotAt(target common.Address, mappingSlot [32]byte, idx *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.GetMappingSlotAt(&_VmSafe.TransactOpts, target, mappingSlot, idx)
+}
+
+// GetNonce0 is a paid mutator transaction binding the contract method 0xa5748aad.
+//
+// Solidity: function getNonce((address,uint256,uint256,uint256) wallet) returns(uint64 nonce)
+func (_VmSafe *VmSafeTransactor) GetNonce0(opts *bind.TransactOpts, wallet VmSafeWallet) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "getNonce0", wallet)
+}
+
+// GetNonce0 is a paid mutator transaction binding the contract method 0xa5748aad.
+//
+// Solidity: function getNonce((address,uint256,uint256,uint256) wallet) returns(uint64 nonce)
+func (_VmSafe *VmSafeSession) GetNonce0(wallet VmSafeWallet) (*types.Transaction, error) {
+	return _VmSafe.Contract.GetNonce0(&_VmSafe.TransactOpts, wallet)
+}
+
+// GetNonce0 is a paid mutator transaction binding the contract method 0xa5748aad.
+//
+// Solidity: function getNonce((address,uint256,uint256,uint256) wallet) returns(uint64 nonce)
+func (_VmSafe *VmSafeTransactorSession) GetNonce0(wallet VmSafeWallet) (*types.Transaction, error) {
+	return _VmSafe.Contract.GetNonce0(&_VmSafe.TransactOpts, wallet)
+}
+
+// GetRecordedLogs is a paid mutator transaction binding the contract method 0x191553a4.
+//
+// Solidity: function getRecordedLogs() returns((bytes32[],bytes,address)[] logs)
+func (_VmSafe *VmSafeTransactor) GetRecordedLogs(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "getRecordedLogs")
+}
+
+// GetRecordedLogs is a paid mutator transaction binding the contract method 0x191553a4.
+//
+// Solidity: function getRecordedLogs() returns((bytes32[],bytes,address)[] logs)
+func (_VmSafe *VmSafeSession) GetRecordedLogs() (*types.Transaction, error) {
+	return _VmSafe.Contract.GetRecordedLogs(&_VmSafe.TransactOpts)
+}
+
+// GetRecordedLogs is a paid mutator transaction binding the contract method 0x191553a4.
+//
+// Solidity: function getRecordedLogs() returns((bytes32[],bytes,address)[] logs)
+func (_VmSafe *VmSafeTransactorSession) GetRecordedLogs() (*types.Transaction, error) {
+	return _VmSafe.Contract.GetRecordedLogs(&_VmSafe.TransactOpts)
+}
+
+// GetWallets is a paid mutator transaction binding the contract method 0xdb7a4605.
+//
+// Solidity: function getWallets() returns(address[] wallets)
+func (_VmSafe *VmSafeTransactor) GetWallets(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "getWallets")
+}
+
+// GetWallets is a paid mutator transaction binding the contract method 0xdb7a4605.
+//
+// Solidity: function getWallets() returns(address[] wallets)
+func (_VmSafe *VmSafeSession) GetWallets() (*types.Transaction, error) {
+	return _VmSafe.Contract.GetWallets(&_VmSafe.TransactOpts)
+}
+
+// GetWallets is a paid mutator transaction binding the contract method 0xdb7a4605.
+//
+// Solidity: function getWallets() returns(address[] wallets)
+func (_VmSafe *VmSafeTransactorSession) GetWallets() (*types.Transaction, error) {
+	return _VmSafe.Contract.GetWallets(&_VmSafe.TransactOpts)
+}
+
+// Label is a paid mutator transaction binding the contract method 0xc657c718.
+//
+// Solidity: function label(address account, string newLabel) returns()
+func (_VmSafe *VmSafeTransactor) Label(opts *bind.TransactOpts, account common.Address, newLabel string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "label", account, newLabel)
+}
+
+// Label is a paid mutator transaction binding the contract method 0xc657c718.
+//
+// Solidity: function label(address account, string newLabel) returns()
+func (_VmSafe *VmSafeSession) Label(account common.Address, newLabel string) (*types.Transaction, error) {
+	return _VmSafe.Contract.Label(&_VmSafe.TransactOpts, account, newLabel)
+}
+
+// Label is a paid mutator transaction binding the contract method 0xc657c718.
+//
+// Solidity: function label(address account, string newLabel) returns()
+func (_VmSafe *VmSafeTransactorSession) Label(account common.Address, newLabel string) (*types.Transaction, error) {
+	return _VmSafe.Contract.Label(&_VmSafe.TransactOpts, account, newLabel)
+}
+
+// PauseGasMetering is a paid mutator transaction binding the contract method 0xd1a5b36f.
+//
+// Solidity: function pauseGasMetering() returns()
+func (_VmSafe *VmSafeTransactor) PauseGasMetering(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "pauseGasMetering")
+}
+
+// PauseGasMetering is a paid mutator transaction binding the contract method 0xd1a5b36f.
+//
+// Solidity: function pauseGasMetering() returns()
+func (_VmSafe *VmSafeSession) PauseGasMetering() (*types.Transaction, error) {
+	return _VmSafe.Contract.PauseGasMetering(&_VmSafe.TransactOpts)
+}
+
+// PauseGasMetering is a paid mutator transaction binding the contract method 0xd1a5b36f.
+//
+// Solidity: function pauseGasMetering() returns()
+func (_VmSafe *VmSafeTransactorSession) PauseGasMetering() (*types.Transaction, error) {
+	return _VmSafe.Contract.PauseGasMetering(&_VmSafe.TransactOpts)
+}
+
+// Prompt is a paid mutator transaction binding the contract method 0x47eaf474.
+//
+// Solidity: function prompt(string promptText) returns(string input)
+func (_VmSafe *VmSafeTransactor) Prompt(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "prompt", promptText)
+}
+
+// Prompt is a paid mutator transaction binding the contract method 0x47eaf474.
+//
+// Solidity: function prompt(string promptText) returns(string input)
+func (_VmSafe *VmSafeSession) Prompt(promptText string) (*types.Transaction, error) {
+	return _VmSafe.Contract.Prompt(&_VmSafe.TransactOpts, promptText)
+}
+
+// Prompt is a paid mutator transaction binding the contract method 0x47eaf474.
+//
+// Solidity: function prompt(string promptText) returns(string input)
+func (_VmSafe *VmSafeTransactorSession) Prompt(promptText string) (*types.Transaction, error) {
+	return _VmSafe.Contract.Prompt(&_VmSafe.TransactOpts, promptText)
+}
+
+// PromptAddress is a paid mutator transaction binding the contract method 0x62ee05f4.
+//
+// Solidity: function promptAddress(string promptText) returns(address)
+func (_VmSafe *VmSafeTransactor) PromptAddress(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "promptAddress", promptText)
+}
+
+// PromptAddress is a paid mutator transaction binding the contract method 0x62ee05f4.
+//
+// Solidity: function promptAddress(string promptText) returns(address)
+func (_VmSafe *VmSafeSession) PromptAddress(promptText string) (*types.Transaction, error) {
+	return _VmSafe.Contract.PromptAddress(&_VmSafe.TransactOpts, promptText)
+}
+
+// PromptAddress is a paid mutator transaction binding the contract method 0x62ee05f4.
+//
+// Solidity: function promptAddress(string promptText) returns(address)
+func (_VmSafe *VmSafeTransactorSession) PromptAddress(promptText string) (*types.Transaction, error) {
+	return _VmSafe.Contract.PromptAddress(&_VmSafe.TransactOpts, promptText)
+}
+
+// PromptSecret is a paid mutator transaction binding the contract method 0x1e279d41.
+//
+// Solidity: function promptSecret(string promptText) returns(string input)
+func (_VmSafe *VmSafeTransactor) PromptSecret(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "promptSecret", promptText)
+}
+
+// PromptSecret is a paid mutator transaction binding the contract method 0x1e279d41.
+//
+// Solidity: function promptSecret(string promptText) returns(string input)
+func (_VmSafe *VmSafeSession) PromptSecret(promptText string) (*types.Transaction, error) {
+	return _VmSafe.Contract.PromptSecret(&_VmSafe.TransactOpts, promptText)
+}
+
+// PromptSecret is a paid mutator transaction binding the contract method 0x1e279d41.
+//
+// Solidity: function promptSecret(string promptText) returns(string input)
+func (_VmSafe *VmSafeTransactorSession) PromptSecret(promptText string) (*types.Transaction, error) {
+	return _VmSafe.Contract.PromptSecret(&_VmSafe.TransactOpts, promptText)
+}
+
+// PromptSecretUint is a paid mutator transaction binding the contract method 0x69ca02b7.
+//
+// Solidity: function promptSecretUint(string promptText) returns(uint256)
+func (_VmSafe *VmSafeTransactor) PromptSecretUint(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "promptSecretUint", promptText)
+}
+
+// PromptSecretUint is a paid mutator transaction binding the contract method 0x69ca02b7.
+//
+// Solidity: function promptSecretUint(string promptText) returns(uint256)
+func (_VmSafe *VmSafeSession) PromptSecretUint(promptText string) (*types.Transaction, error) {
+	return _VmSafe.Contract.PromptSecretUint(&_VmSafe.TransactOpts, promptText)
+}
+
+// PromptSecretUint is a paid mutator transaction binding the contract method 0x69ca02b7.
+//
+// Solidity: function promptSecretUint(string promptText) returns(uint256)
+func (_VmSafe *VmSafeTransactorSession) PromptSecretUint(promptText string) (*types.Transaction, error) {
+	return _VmSafe.Contract.PromptSecretUint(&_VmSafe.TransactOpts, promptText)
+}
+
+// PromptUint is a paid mutator transaction binding the contract method 0x652fd489.
+//
+// Solidity: function promptUint(string promptText) returns(uint256)
+func (_VmSafe *VmSafeTransactor) PromptUint(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "promptUint", promptText)
+}
+
+// PromptUint is a paid mutator transaction binding the contract method 0x652fd489.
+//
+// Solidity: function promptUint(string promptText) returns(uint256)
+func (_VmSafe *VmSafeSession) PromptUint(promptText string) (*types.Transaction, error) {
+	return _VmSafe.Contract.PromptUint(&_VmSafe.TransactOpts, promptText)
+}
+
+// PromptUint is a paid mutator transaction binding the contract method 0x652fd489.
+//
+// Solidity: function promptUint(string promptText) returns(uint256)
+func (_VmSafe *VmSafeTransactorSession) PromptUint(promptText string) (*types.Transaction, error) {
+	return _VmSafe.Contract.PromptUint(&_VmSafe.TransactOpts, promptText)
+}
+
+// RandomAddress is a paid mutator transaction binding the contract method 0xd5bee9f5.
+//
+// Solidity: function randomAddress() returns(address)
+func (_VmSafe *VmSafeTransactor) RandomAddress(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "randomAddress")
+}
+
+// RandomAddress is a paid mutator transaction binding the contract method 0xd5bee9f5.
+//
+// Solidity: function randomAddress() returns(address)
+func (_VmSafe *VmSafeSession) RandomAddress() (*types.Transaction, error) {
+	return _VmSafe.Contract.RandomAddress(&_VmSafe.TransactOpts)
+}
+
+// RandomAddress is a paid mutator transaction binding the contract method 0xd5bee9f5.
+//
+// Solidity: function randomAddress() returns(address)
+func (_VmSafe *VmSafeTransactorSession) RandomAddress() (*types.Transaction, error) {
+	return _VmSafe.Contract.RandomAddress(&_VmSafe.TransactOpts)
+}
+
+// RandomUint is a paid mutator transaction binding the contract method 0x25124730.
+//
+// Solidity: function randomUint() returns(uint256)
+func (_VmSafe *VmSafeTransactor) RandomUint(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "randomUint")
+}
+
+// RandomUint is a paid mutator transaction binding the contract method 0x25124730.
+//
+// Solidity: function randomUint() returns(uint256)
+func (_VmSafe *VmSafeSession) RandomUint() (*types.Transaction, error) {
+	return _VmSafe.Contract.RandomUint(&_VmSafe.TransactOpts)
+}
+
+// RandomUint is a paid mutator transaction binding the contract method 0x25124730.
+//
+// Solidity: function randomUint() returns(uint256)
+func (_VmSafe *VmSafeTransactorSession) RandomUint() (*types.Transaction, error) {
+	return _VmSafe.Contract.RandomUint(&_VmSafe.TransactOpts)
+}
+
+// RandomUint1 is a paid mutator transaction binding the contract method 0xd61b051b.
+//
+// Solidity: function randomUint(uint256 min, uint256 max) returns(uint256)
+func (_VmSafe *VmSafeTransactor) RandomUint1(opts *bind.TransactOpts, min *big.Int, max *big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "randomUint1", min, max)
+}
+
+// RandomUint1 is a paid mutator transaction binding the contract method 0xd61b051b.
+//
+// Solidity: function randomUint(uint256 min, uint256 max) returns(uint256)
+func (_VmSafe *VmSafeSession) RandomUint1(min *big.Int, max *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.RandomUint1(&_VmSafe.TransactOpts, min, max)
+}
+
+// RandomUint1 is a paid mutator transaction binding the contract method 0xd61b051b.
+//
+// Solidity: function randomUint(uint256 min, uint256 max) returns(uint256)
+func (_VmSafe *VmSafeTransactorSession) RandomUint1(min *big.Int, max *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.RandomUint1(&_VmSafe.TransactOpts, min, max)
+}
+
+// Record is a paid mutator transaction binding the contract method 0x266cf109.
+//
+// Solidity: function record() returns()
+func (_VmSafe *VmSafeTransactor) Record(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "record")
+}
+
+// Record is a paid mutator transaction binding the contract method 0x266cf109.
+//
+// Solidity: function record() returns()
+func (_VmSafe *VmSafeSession) Record() (*types.Transaction, error) {
+	return _VmSafe.Contract.Record(&_VmSafe.TransactOpts)
+}
+
+// Record is a paid mutator transaction binding the contract method 0x266cf109.
+//
+// Solidity: function record() returns()
+func (_VmSafe *VmSafeTransactorSession) Record() (*types.Transaction, error) {
+	return _VmSafe.Contract.Record(&_VmSafe.TransactOpts)
+}
+
+// RecordLogs is a paid mutator transaction binding the contract method 0x41af2f52.
+//
+// Solidity: function recordLogs() returns()
+func (_VmSafe *VmSafeTransactor) RecordLogs(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "recordLogs")
+}
+
+// RecordLogs is a paid mutator transaction binding the contract method 0x41af2f52.
+//
+// Solidity: function recordLogs() returns()
+func (_VmSafe *VmSafeSession) RecordLogs() (*types.Transaction, error) {
+	return _VmSafe.Contract.RecordLogs(&_VmSafe.TransactOpts)
+}
+
+// RecordLogs is a paid mutator transaction binding the contract method 0x41af2f52.
+//
+// Solidity: function recordLogs() returns()
+func (_VmSafe *VmSafeTransactorSession) RecordLogs() (*types.Transaction, error) {
+	return _VmSafe.Contract.RecordLogs(&_VmSafe.TransactOpts)
+}
+
+// RememberKey is a paid mutator transaction binding the contract method 0x22100064.
+//
+// Solidity: function rememberKey(uint256 privateKey) returns(address keyAddr)
+func (_VmSafe *VmSafeTransactor) RememberKey(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "rememberKey", privateKey)
+}
+
+// RememberKey is a paid mutator transaction binding the contract method 0x22100064.
+//
+// Solidity: function rememberKey(uint256 privateKey) returns(address keyAddr)
+func (_VmSafe *VmSafeSession) RememberKey(privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.RememberKey(&_VmSafe.TransactOpts, privateKey)
+}
+
+// RememberKey is a paid mutator transaction binding the contract method 0x22100064.
+//
+// Solidity: function rememberKey(uint256 privateKey) returns(address keyAddr)
+func (_VmSafe *VmSafeTransactorSession) RememberKey(privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.RememberKey(&_VmSafe.TransactOpts, privateKey)
+}
+
+// RememberKeys is a paid mutator transaction binding the contract method 0x97cb9189.
+//
+// Solidity: function rememberKeys(string mnemonic, string derivationPath, uint32 count) returns(address[] keyAddrs)
+func (_VmSafe *VmSafeTransactor) RememberKeys(opts *bind.TransactOpts, mnemonic string, derivationPath string, count uint32) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "rememberKeys", mnemonic, derivationPath, count)
+}
+
+// RememberKeys is a paid mutator transaction binding the contract method 0x97cb9189.
+//
+// Solidity: function rememberKeys(string mnemonic, string derivationPath, uint32 count) returns(address[] keyAddrs)
+func (_VmSafe *VmSafeSession) RememberKeys(mnemonic string, derivationPath string, count uint32) (*types.Transaction, error) {
+	return _VmSafe.Contract.RememberKeys(&_VmSafe.TransactOpts, mnemonic, derivationPath, count)
+}
+
+// RememberKeys is a paid mutator transaction binding the contract method 0x97cb9189.
+//
+// Solidity: function rememberKeys(string mnemonic, string derivationPath, uint32 count) returns(address[] keyAddrs)
+func (_VmSafe *VmSafeTransactorSession) RememberKeys(mnemonic string, derivationPath string, count uint32) (*types.Transaction, error) {
+	return _VmSafe.Contract.RememberKeys(&_VmSafe.TransactOpts, mnemonic, derivationPath, count)
+}
+
+// RememberKeys0 is a paid mutator transaction binding the contract method 0xf8d58eaf.
+//
+// Solidity: function rememberKeys(string mnemonic, string derivationPath, string language, uint32 count) returns(address[] keyAddrs)
+func (_VmSafe *VmSafeTransactor) RememberKeys0(opts *bind.TransactOpts, mnemonic string, derivationPath string, language string, count uint32) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "rememberKeys0", mnemonic, derivationPath, language, count)
+}
+
+// RememberKeys0 is a paid mutator transaction binding the contract method 0xf8d58eaf.
+//
+// Solidity: function rememberKeys(string mnemonic, string derivationPath, string language, uint32 count) returns(address[] keyAddrs)
+func (_VmSafe *VmSafeSession) RememberKeys0(mnemonic string, derivationPath string, language string, count uint32) (*types.Transaction, error) {
+	return _VmSafe.Contract.RememberKeys0(&_VmSafe.TransactOpts, mnemonic, derivationPath, language, count)
+}
+
+// RememberKeys0 is a paid mutator transaction binding the contract method 0xf8d58eaf.
+//
+// Solidity: function rememberKeys(string mnemonic, string derivationPath, string language, uint32 count) returns(address[] keyAddrs)
+func (_VmSafe *VmSafeTransactorSession) RememberKeys0(mnemonic string, derivationPath string, language string, count uint32) (*types.Transaction, error) {
+	return _VmSafe.Contract.RememberKeys0(&_VmSafe.TransactOpts, mnemonic, derivationPath, language, count)
+}
+
+// RemoveDir is a paid mutator transaction binding the contract method 0x45c62011.
+//
+// Solidity: function removeDir(string path, bool recursive) returns()
+func (_VmSafe *VmSafeTransactor) RemoveDir(opts *bind.TransactOpts, path string, recursive bool) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "removeDir", path, recursive)
+}
+
+// RemoveDir is a paid mutator transaction binding the contract method 0x45c62011.
+//
+// Solidity: function removeDir(string path, bool recursive) returns()
+func (_VmSafe *VmSafeSession) RemoveDir(path string, recursive bool) (*types.Transaction, error) {
+	return _VmSafe.Contract.RemoveDir(&_VmSafe.TransactOpts, path, recursive)
+}
+
+// RemoveDir is a paid mutator transaction binding the contract method 0x45c62011.
+//
+// Solidity: function removeDir(string path, bool recursive) returns()
+func (_VmSafe *VmSafeTransactorSession) RemoveDir(path string, recursive bool) (*types.Transaction, error) {
+	return _VmSafe.Contract.RemoveDir(&_VmSafe.TransactOpts, path, recursive)
+}
+
+// RemoveFile is a paid mutator transaction binding the contract method 0xf1afe04d.
+//
+// Solidity: function removeFile(string path) returns()
+func (_VmSafe *VmSafeTransactor) RemoveFile(opts *bind.TransactOpts, path string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "removeFile", path)
+}
+
+// RemoveFile is a paid mutator transaction binding the contract method 0xf1afe04d.
+//
+// Solidity: function removeFile(string path) returns()
+func (_VmSafe *VmSafeSession) RemoveFile(path string) (*types.Transaction, error) {
+	return _VmSafe.Contract.RemoveFile(&_VmSafe.TransactOpts, path)
+}
+
+// RemoveFile is a paid mutator transaction binding the contract method 0xf1afe04d.
+//
+// Solidity: function removeFile(string path) returns()
+func (_VmSafe *VmSafeTransactorSession) RemoveFile(path string) (*types.Transaction, error) {
+	return _VmSafe.Contract.RemoveFile(&_VmSafe.TransactOpts, path)
+}
+
+// ResetGasMetering is a paid mutator transaction binding the contract method 0xbe367dd3.
+//
+// Solidity: function resetGasMetering() returns()
+func (_VmSafe *VmSafeTransactor) ResetGasMetering(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "resetGasMetering")
+}
+
+// ResetGasMetering is a paid mutator transaction binding the contract method 0xbe367dd3.
+//
+// Solidity: function resetGasMetering() returns()
+func (_VmSafe *VmSafeSession) ResetGasMetering() (*types.Transaction, error) {
+	return _VmSafe.Contract.ResetGasMetering(&_VmSafe.TransactOpts)
+}
+
+// ResetGasMetering is a paid mutator transaction binding the contract method 0xbe367dd3.
+//
+// Solidity: function resetGasMetering() returns()
+func (_VmSafe *VmSafeTransactorSession) ResetGasMetering() (*types.Transaction, error) {
+	return _VmSafe.Contract.ResetGasMetering(&_VmSafe.TransactOpts)
+}
+
+// ResumeGasMetering is a paid mutator transaction binding the contract method 0x2bcd50e0.
+//
+// Solidity: function resumeGasMetering() returns()
+func (_VmSafe *VmSafeTransactor) ResumeGasMetering(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "resumeGasMetering")
+}
+
+// ResumeGasMetering is a paid mutator transaction binding the contract method 0x2bcd50e0.
+//
+// Solidity: function resumeGasMetering() returns()
+func (_VmSafe *VmSafeSession) ResumeGasMetering() (*types.Transaction, error) {
+	return _VmSafe.Contract.ResumeGasMetering(&_VmSafe.TransactOpts)
+}
+
+// ResumeGasMetering is a paid mutator transaction binding the contract method 0x2bcd50e0.
+//
+// Solidity: function resumeGasMetering() returns()
+func (_VmSafe *VmSafeTransactorSession) ResumeGasMetering() (*types.Transaction, error) {
+	return _VmSafe.Contract.ResumeGasMetering(&_VmSafe.TransactOpts)
+}
+
+// Rpc is a paid mutator transaction binding the contract method 0x0199a220.
+//
+// Solidity: function rpc(string urlOrAlias, string method, string params) returns(bytes data)
+func (_VmSafe *VmSafeTransactor) Rpc(opts *bind.TransactOpts, urlOrAlias string, method string, params string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "rpc", urlOrAlias, method, params)
+}
+
+// Rpc is a paid mutator transaction binding the contract method 0x0199a220.
+//
+// Solidity: function rpc(string urlOrAlias, string method, string params) returns(bytes data)
+func (_VmSafe *VmSafeSession) Rpc(urlOrAlias string, method string, params string) (*types.Transaction, error) {
+	return _VmSafe.Contract.Rpc(&_VmSafe.TransactOpts, urlOrAlias, method, params)
+}
+
+// Rpc is a paid mutator transaction binding the contract method 0x0199a220.
+//
+// Solidity: function rpc(string urlOrAlias, string method, string params) returns(bytes data)
+func (_VmSafe *VmSafeTransactorSession) Rpc(urlOrAlias string, method string, params string) (*types.Transaction, error) {
+	return _VmSafe.Contract.Rpc(&_VmSafe.TransactOpts, urlOrAlias, method, params)
+}
+
+// Rpc0 is a paid mutator transaction binding the contract method 0x1206c8a8.
+//
+// Solidity: function rpc(string method, string params) returns(bytes data)
+func (_VmSafe *VmSafeTransactor) Rpc0(opts *bind.TransactOpts, method string, params string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "rpc0", method, params)
+}
+
+// Rpc0 is a paid mutator transaction binding the contract method 0x1206c8a8.
+//
+// Solidity: function rpc(string method, string params) returns(bytes data)
+func (_VmSafe *VmSafeSession) Rpc0(method string, params string) (*types.Transaction, error) {
+	return _VmSafe.Contract.Rpc0(&_VmSafe.TransactOpts, method, params)
+}
+
+// Rpc0 is a paid mutator transaction binding the contract method 0x1206c8a8.
+//
+// Solidity: function rpc(string method, string params) returns(bytes data)
+func (_VmSafe *VmSafeTransactorSession) Rpc0(method string, params string) (*types.Transaction, error) {
+	return _VmSafe.Contract.Rpc0(&_VmSafe.TransactOpts, method, params)
+}
+
+// SerializeAddress is a paid mutator transaction binding the contract method 0x1e356e1a.
+//
+// Solidity: function serializeAddress(string objectKey, string valueKey, address[] values) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeAddress(opts *bind.TransactOpts, objectKey string, valueKey string, values []common.Address) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeAddress", objectKey, valueKey, values)
+}
+
+// SerializeAddress is a paid mutator transaction binding the contract method 0x1e356e1a.
+//
+// Solidity: function serializeAddress(string objectKey, string valueKey, address[] values) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeAddress(objectKey string, valueKey string, values []common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeAddress(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeAddress is a paid mutator transaction binding the contract method 0x1e356e1a.
+//
+// Solidity: function serializeAddress(string objectKey, string valueKey, address[] values) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeAddress(objectKey string, valueKey string, values []common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeAddress(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeAddress0 is a paid mutator transaction binding the contract method 0x972c6062.
+//
+// Solidity: function serializeAddress(string objectKey, string valueKey, address value) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeAddress0(opts *bind.TransactOpts, objectKey string, valueKey string, value common.Address) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeAddress0", objectKey, valueKey, value)
+}
+
+// SerializeAddress0 is a paid mutator transaction binding the contract method 0x972c6062.
+//
+// Solidity: function serializeAddress(string objectKey, string valueKey, address value) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeAddress0(objectKey string, valueKey string, value common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeAddress0(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeAddress0 is a paid mutator transaction binding the contract method 0x972c6062.
+//
+// Solidity: function serializeAddress(string objectKey, string valueKey, address value) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeAddress0(objectKey string, valueKey string, value common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeAddress0(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeBool is a paid mutator transaction binding the contract method 0x92925aa1.
+//
+// Solidity: function serializeBool(string objectKey, string valueKey, bool[] values) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeBool(opts *bind.TransactOpts, objectKey string, valueKey string, values []bool) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeBool", objectKey, valueKey, values)
+}
+
+// SerializeBool is a paid mutator transaction binding the contract method 0x92925aa1.
+//
+// Solidity: function serializeBool(string objectKey, string valueKey, bool[] values) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeBool(objectKey string, valueKey string, values []bool) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeBool(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeBool is a paid mutator transaction binding the contract method 0x92925aa1.
+//
+// Solidity: function serializeBool(string objectKey, string valueKey, bool[] values) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeBool(objectKey string, valueKey string, values []bool) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeBool(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeBool0 is a paid mutator transaction binding the contract method 0xac22e971.
+//
+// Solidity: function serializeBool(string objectKey, string valueKey, bool value) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeBool0(opts *bind.TransactOpts, objectKey string, valueKey string, value bool) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeBool0", objectKey, valueKey, value)
+}
+
+// SerializeBool0 is a paid mutator transaction binding the contract method 0xac22e971.
+//
+// Solidity: function serializeBool(string objectKey, string valueKey, bool value) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeBool0(objectKey string, valueKey string, value bool) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeBool0(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeBool0 is a paid mutator transaction binding the contract method 0xac22e971.
+//
+// Solidity: function serializeBool(string objectKey, string valueKey, bool value) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeBool0(objectKey string, valueKey string, value bool) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeBool0(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeBytes is a paid mutator transaction binding the contract method 0x9884b232.
+//
+// Solidity: function serializeBytes(string objectKey, string valueKey, bytes[] values) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeBytes(opts *bind.TransactOpts, objectKey string, valueKey string, values [][]byte) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeBytes", objectKey, valueKey, values)
+}
+
+// SerializeBytes is a paid mutator transaction binding the contract method 0x9884b232.
+//
+// Solidity: function serializeBytes(string objectKey, string valueKey, bytes[] values) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeBytes(objectKey string, valueKey string, values [][]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeBytes(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeBytes is a paid mutator transaction binding the contract method 0x9884b232.
+//
+// Solidity: function serializeBytes(string objectKey, string valueKey, bytes[] values) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeBytes(objectKey string, valueKey string, values [][]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeBytes(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeBytes0 is a paid mutator transaction binding the contract method 0xf21d52c7.
+//
+// Solidity: function serializeBytes(string objectKey, string valueKey, bytes value) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeBytes0(opts *bind.TransactOpts, objectKey string, valueKey string, value []byte) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeBytes0", objectKey, valueKey, value)
+}
+
+// SerializeBytes0 is a paid mutator transaction binding the contract method 0xf21d52c7.
+//
+// Solidity: function serializeBytes(string objectKey, string valueKey, bytes value) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeBytes0(objectKey string, valueKey string, value []byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeBytes0(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeBytes0 is a paid mutator transaction binding the contract method 0xf21d52c7.
+//
+// Solidity: function serializeBytes(string objectKey, string valueKey, bytes value) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeBytes0(objectKey string, valueKey string, value []byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeBytes0(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeBytes32 is a paid mutator transaction binding the contract method 0x201e43e2.
+//
+// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32[] values) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeBytes32(opts *bind.TransactOpts, objectKey string, valueKey string, values [][32]byte) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeBytes32", objectKey, valueKey, values)
+}
+
+// SerializeBytes32 is a paid mutator transaction binding the contract method 0x201e43e2.
+//
+// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32[] values) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeBytes32(objectKey string, valueKey string, values [][32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeBytes32(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeBytes32 is a paid mutator transaction binding the contract method 0x201e43e2.
+//
+// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32[] values) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeBytes32(objectKey string, valueKey string, values [][32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeBytes32(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeBytes320 is a paid mutator transaction binding the contract method 0x2d812b44.
+//
+// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32 value) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeBytes320(opts *bind.TransactOpts, objectKey string, valueKey string, value [32]byte) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeBytes320", objectKey, valueKey, value)
+}
+
+// SerializeBytes320 is a paid mutator transaction binding the contract method 0x2d812b44.
+//
+// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32 value) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeBytes320(objectKey string, valueKey string, value [32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeBytes320(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeBytes320 is a paid mutator transaction binding the contract method 0x2d812b44.
+//
+// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32 value) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeBytes320(objectKey string, valueKey string, value [32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeBytes320(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeInt is a paid mutator transaction binding the contract method 0x3f33db60.
+//
+// Solidity: function serializeInt(string objectKey, string valueKey, int256 value) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeInt(opts *bind.TransactOpts, objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeInt", objectKey, valueKey, value)
+}
+
+// SerializeInt is a paid mutator transaction binding the contract method 0x3f33db60.
+//
+// Solidity: function serializeInt(string objectKey, string valueKey, int256 value) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeInt(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeInt(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeInt is a paid mutator transaction binding the contract method 0x3f33db60.
+//
+// Solidity: function serializeInt(string objectKey, string valueKey, int256 value) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeInt(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeInt(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeInt0 is a paid mutator transaction binding the contract method 0x7676e127.
+//
+// Solidity: function serializeInt(string objectKey, string valueKey, int256[] values) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeInt0(opts *bind.TransactOpts, objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeInt0", objectKey, valueKey, values)
+}
+
+// SerializeInt0 is a paid mutator transaction binding the contract method 0x7676e127.
+//
+// Solidity: function serializeInt(string objectKey, string valueKey, int256[] values) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeInt0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeInt0(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeInt0 is a paid mutator transaction binding the contract method 0x7676e127.
+//
+// Solidity: function serializeInt(string objectKey, string valueKey, int256[] values) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeInt0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeInt0(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeJson is a paid mutator transaction binding the contract method 0x9b3358b0.
+//
+// Solidity: function serializeJson(string objectKey, string value) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeJson(opts *bind.TransactOpts, objectKey string, value string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeJson", objectKey, value)
+}
+
+// SerializeJson is a paid mutator transaction binding the contract method 0x9b3358b0.
+//
+// Solidity: function serializeJson(string objectKey, string value) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeJson(objectKey string, value string) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeJson(&_VmSafe.TransactOpts, objectKey, value)
+}
+
+// SerializeJson is a paid mutator transaction binding the contract method 0x9b3358b0.
+//
+// Solidity: function serializeJson(string objectKey, string value) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeJson(objectKey string, value string) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeJson(&_VmSafe.TransactOpts, objectKey, value)
+}
+
+// SerializeJsonType0 is a paid mutator transaction binding the contract method 0x6f93bccb.
+//
+// Solidity: function serializeJsonType(string objectKey, string valueKey, string typeDescription, bytes value) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeJsonType0(opts *bind.TransactOpts, objectKey string, valueKey string, typeDescription string, value []byte) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeJsonType0", objectKey, valueKey, typeDescription, value)
+}
+
+// SerializeJsonType0 is a paid mutator transaction binding the contract method 0x6f93bccb.
+//
+// Solidity: function serializeJsonType(string objectKey, string valueKey, string typeDescription, bytes value) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeJsonType0(objectKey string, valueKey string, typeDescription string, value []byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeJsonType0(&_VmSafe.TransactOpts, objectKey, valueKey, typeDescription, value)
+}
+
+// SerializeJsonType0 is a paid mutator transaction binding the contract method 0x6f93bccb.
+//
+// Solidity: function serializeJsonType(string objectKey, string valueKey, string typeDescription, bytes value) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeJsonType0(objectKey string, valueKey string, typeDescription string, value []byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeJsonType0(&_VmSafe.TransactOpts, objectKey, valueKey, typeDescription, value)
+}
+
+// SerializeString is a paid mutator transaction binding the contract method 0x561cd6f3.
+//
+// Solidity: function serializeString(string objectKey, string valueKey, string[] values) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeString(opts *bind.TransactOpts, objectKey string, valueKey string, values []string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeString", objectKey, valueKey, values)
+}
+
+// SerializeString is a paid mutator transaction binding the contract method 0x561cd6f3.
+//
+// Solidity: function serializeString(string objectKey, string valueKey, string[] values) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeString(objectKey string, valueKey string, values []string) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeString(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeString is a paid mutator transaction binding the contract method 0x561cd6f3.
+//
+// Solidity: function serializeString(string objectKey, string valueKey, string[] values) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeString(objectKey string, valueKey string, values []string) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeString(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeString0 is a paid mutator transaction binding the contract method 0x88da6d35.
+//
+// Solidity: function serializeString(string objectKey, string valueKey, string value) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeString0(opts *bind.TransactOpts, objectKey string, valueKey string, value string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeString0", objectKey, valueKey, value)
+}
+
+// SerializeString0 is a paid mutator transaction binding the contract method 0x88da6d35.
+//
+// Solidity: function serializeString(string objectKey, string valueKey, string value) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeString0(objectKey string, valueKey string, value string) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeString0(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeString0 is a paid mutator transaction binding the contract method 0x88da6d35.
+//
+// Solidity: function serializeString(string objectKey, string valueKey, string value) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeString0(objectKey string, valueKey string, value string) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeString0(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeUint is a paid mutator transaction binding the contract method 0x129e9002.
+//
+// Solidity: function serializeUint(string objectKey, string valueKey, uint256 value) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeUint(opts *bind.TransactOpts, objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeUint", objectKey, valueKey, value)
+}
+
+// SerializeUint is a paid mutator transaction binding the contract method 0x129e9002.
+//
+// Solidity: function serializeUint(string objectKey, string valueKey, uint256 value) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeUint(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeUint(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeUint is a paid mutator transaction binding the contract method 0x129e9002.
+//
+// Solidity: function serializeUint(string objectKey, string valueKey, uint256 value) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeUint(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeUint(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeUint0 is a paid mutator transaction binding the contract method 0xfee9a469.
+//
+// Solidity: function serializeUint(string objectKey, string valueKey, uint256[] values) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeUint0(opts *bind.TransactOpts, objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeUint0", objectKey, valueKey, values)
+}
+
+// SerializeUint0 is a paid mutator transaction binding the contract method 0xfee9a469.
+//
+// Solidity: function serializeUint(string objectKey, string valueKey, uint256[] values) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeUint0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeUint0(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeUint0 is a paid mutator transaction binding the contract method 0xfee9a469.
+//
+// Solidity: function serializeUint(string objectKey, string valueKey, uint256[] values) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeUint0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeUint0(&_VmSafe.TransactOpts, objectKey, valueKey, values)
+}
+
+// SerializeUintToHex is a paid mutator transaction binding the contract method 0xae5a2ae8.
+//
+// Solidity: function serializeUintToHex(string objectKey, string valueKey, uint256 value) returns(string json)
+func (_VmSafe *VmSafeTransactor) SerializeUintToHex(opts *bind.TransactOpts, objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "serializeUintToHex", objectKey, valueKey, value)
+}
+
+// SerializeUintToHex is a paid mutator transaction binding the contract method 0xae5a2ae8.
+//
+// Solidity: function serializeUintToHex(string objectKey, string valueKey, uint256 value) returns(string json)
+func (_VmSafe *VmSafeSession) SerializeUintToHex(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeUintToHex(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SerializeUintToHex is a paid mutator transaction binding the contract method 0xae5a2ae8.
+//
+// Solidity: function serializeUintToHex(string objectKey, string valueKey, uint256 value) returns(string json)
+func (_VmSafe *VmSafeTransactorSession) SerializeUintToHex(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SerializeUintToHex(&_VmSafe.TransactOpts, objectKey, valueKey, value)
+}
+
+// SetArbitraryStorage is a paid mutator transaction binding the contract method 0xe1631837.
+//
+// Solidity: function setArbitraryStorage(address target) returns()
+func (_VmSafe *VmSafeTransactor) SetArbitraryStorage(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "setArbitraryStorage", target)
+}
+
+// SetArbitraryStorage is a paid mutator transaction binding the contract method 0xe1631837.
+//
+// Solidity: function setArbitraryStorage(address target) returns()
+func (_VmSafe *VmSafeSession) SetArbitraryStorage(target common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.SetArbitraryStorage(&_VmSafe.TransactOpts, target)
+}
+
+// SetArbitraryStorage is a paid mutator transaction binding the contract method 0xe1631837.
+//
+// Solidity: function setArbitraryStorage(address target) returns()
+func (_VmSafe *VmSafeTransactorSession) SetArbitraryStorage(target common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.SetArbitraryStorage(&_VmSafe.TransactOpts, target)
+}
+
+// SetEnv is a paid mutator transaction binding the contract method 0x3d5923ee.
+//
+// Solidity: function setEnv(string name, string value) returns()
+func (_VmSafe *VmSafeTransactor) SetEnv(opts *bind.TransactOpts, name string, value string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "setEnv", name, value)
+}
+
+// SetEnv is a paid mutator transaction binding the contract method 0x3d5923ee.
+//
+// Solidity: function setEnv(string name, string value) returns()
+func (_VmSafe *VmSafeSession) SetEnv(name string, value string) (*types.Transaction, error) {
+	return _VmSafe.Contract.SetEnv(&_VmSafe.TransactOpts, name, value)
+}
+
+// SetEnv is a paid mutator transaction binding the contract method 0x3d5923ee.
+//
+// Solidity: function setEnv(string name, string value) returns()
+func (_VmSafe *VmSafeTransactorSession) SetEnv(name string, value string) (*types.Transaction, error) {
+	return _VmSafe.Contract.SetEnv(&_VmSafe.TransactOpts, name, value)
+}
+
+// Sign1 is a paid mutator transaction binding the contract method 0xb25c5a25.
+//
+// Solidity: function sign((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(uint8 v, bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeTransactor) Sign1(opts *bind.TransactOpts, wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "sign1", wallet, digest)
+}
+
+// Sign1 is a paid mutator transaction binding the contract method 0xb25c5a25.
+//
+// Solidity: function sign((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(uint8 v, bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeSession) Sign1(wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.Sign1(&_VmSafe.TransactOpts, wallet, digest)
+}
+
+// Sign1 is a paid mutator transaction binding the contract method 0xb25c5a25.
+//
+// Solidity: function sign((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(uint8 v, bytes32 r, bytes32 s)
+func (_VmSafe *VmSafeTransactorSession) Sign1(wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.Sign1(&_VmSafe.TransactOpts, wallet, digest)
+}
+
+// SignAndAttachDelegation is a paid mutator transaction binding the contract method 0xc7fa7288.
+//
+// Solidity: function signAndAttachDelegation(address implementation, uint256 privateKey) returns((uint8,bytes32,bytes32,uint64,address) signedDelegation)
+func (_VmSafe *VmSafeTransactor) SignAndAttachDelegation(opts *bind.TransactOpts, implementation common.Address, privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "signAndAttachDelegation", implementation, privateKey)
+}
+
+// SignAndAttachDelegation is a paid mutator transaction binding the contract method 0xc7fa7288.
+//
+// Solidity: function signAndAttachDelegation(address implementation, uint256 privateKey) returns((uint8,bytes32,bytes32,uint64,address) signedDelegation)
+func (_VmSafe *VmSafeSession) SignAndAttachDelegation(implementation common.Address, privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SignAndAttachDelegation(&_VmSafe.TransactOpts, implementation, privateKey)
+}
+
+// SignAndAttachDelegation is a paid mutator transaction binding the contract method 0xc7fa7288.
+//
+// Solidity: function signAndAttachDelegation(address implementation, uint256 privateKey) returns((uint8,bytes32,bytes32,uint64,address) signedDelegation)
+func (_VmSafe *VmSafeTransactorSession) SignAndAttachDelegation(implementation common.Address, privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SignAndAttachDelegation(&_VmSafe.TransactOpts, implementation, privateKey)
+}
+
+// SignCompact is a paid mutator transaction binding the contract method 0x3d0e292f.
+//
+// Solidity: function signCompact((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(bytes32 r, bytes32 vs)
+func (_VmSafe *VmSafeTransactor) SignCompact(opts *bind.TransactOpts, wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "signCompact", wallet, digest)
+}
+
+// SignCompact is a paid mutator transaction binding the contract method 0x3d0e292f.
+//
+// Solidity: function signCompact((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(bytes32 r, bytes32 vs)
+func (_VmSafe *VmSafeSession) SignCompact(wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.SignCompact(&_VmSafe.TransactOpts, wallet, digest)
+}
+
+// SignCompact is a paid mutator transaction binding the contract method 0x3d0e292f.
+//
+// Solidity: function signCompact((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(bytes32 r, bytes32 vs)
+func (_VmSafe *VmSafeTransactorSession) SignCompact(wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.SignCompact(&_VmSafe.TransactOpts, wallet, digest)
+}
+
+// SignDelegation is a paid mutator transaction binding the contract method 0x5b593c7b.
+//
+// Solidity: function signDelegation(address implementation, uint256 privateKey) returns((uint8,bytes32,bytes32,uint64,address) signedDelegation)
+func (_VmSafe *VmSafeTransactor) SignDelegation(opts *bind.TransactOpts, implementation common.Address, privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "signDelegation", implementation, privateKey)
+}
+
+// SignDelegation is a paid mutator transaction binding the contract method 0x5b593c7b.
+//
+// Solidity: function signDelegation(address implementation, uint256 privateKey) returns((uint8,bytes32,bytes32,uint64,address) signedDelegation)
+func (_VmSafe *VmSafeSession) SignDelegation(implementation common.Address, privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SignDelegation(&_VmSafe.TransactOpts, implementation, privateKey)
+}
+
+// SignDelegation is a paid mutator transaction binding the contract method 0x5b593c7b.
+//
+// Solidity: function signDelegation(address implementation, uint256 privateKey) returns((uint8,bytes32,bytes32,uint64,address) signedDelegation)
+func (_VmSafe *VmSafeTransactorSession) SignDelegation(implementation common.Address, privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.SignDelegation(&_VmSafe.TransactOpts, implementation, privateKey)
+}
+
+// Sleep is a paid mutator transaction binding the contract method 0xfa9d8713.
+//
+// Solidity: function sleep(uint256 duration) returns()
+func (_VmSafe *VmSafeTransactor) Sleep(opts *bind.TransactOpts, duration *big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "sleep", duration)
+}
+
+// Sleep is a paid mutator transaction binding the contract method 0xfa9d8713.
+//
+// Solidity: function sleep(uint256 duration) returns()
+func (_VmSafe *VmSafeSession) Sleep(duration *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.Sleep(&_VmSafe.TransactOpts, duration)
+}
+
+// Sleep is a paid mutator transaction binding the contract method 0xfa9d8713.
+//
+// Solidity: function sleep(uint256 duration) returns()
+func (_VmSafe *VmSafeTransactorSession) Sleep(duration *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.Sleep(&_VmSafe.TransactOpts, duration)
+}
+
+// StartBroadcast is a paid mutator transaction binding the contract method 0x7fb5297f.
+//
+// Solidity: function startBroadcast() returns()
+func (_VmSafe *VmSafeTransactor) StartBroadcast(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "startBroadcast")
+}
+
+// StartBroadcast is a paid mutator transaction binding the contract method 0x7fb5297f.
+//
+// Solidity: function startBroadcast() returns()
+func (_VmSafe *VmSafeSession) StartBroadcast() (*types.Transaction, error) {
+	return _VmSafe.Contract.StartBroadcast(&_VmSafe.TransactOpts)
+}
+
+// StartBroadcast is a paid mutator transaction binding the contract method 0x7fb5297f.
+//
+// Solidity: function startBroadcast() returns()
+func (_VmSafe *VmSafeTransactorSession) StartBroadcast() (*types.Transaction, error) {
+	return _VmSafe.Contract.StartBroadcast(&_VmSafe.TransactOpts)
+}
+
+// StartBroadcast0 is a paid mutator transaction binding the contract method 0x7fec2a8d.
+//
+// Solidity: function startBroadcast(address signer) returns()
+func (_VmSafe *VmSafeTransactor) StartBroadcast0(opts *bind.TransactOpts, signer common.Address) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "startBroadcast0", signer)
+}
+
+// StartBroadcast0 is a paid mutator transaction binding the contract method 0x7fec2a8d.
+//
+// Solidity: function startBroadcast(address signer) returns()
+func (_VmSafe *VmSafeSession) StartBroadcast0(signer common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.StartBroadcast0(&_VmSafe.TransactOpts, signer)
+}
+
+// StartBroadcast0 is a paid mutator transaction binding the contract method 0x7fec2a8d.
+//
+// Solidity: function startBroadcast(address signer) returns()
+func (_VmSafe *VmSafeTransactorSession) StartBroadcast0(signer common.Address) (*types.Transaction, error) {
+	return _VmSafe.Contract.StartBroadcast0(&_VmSafe.TransactOpts, signer)
+}
+
+// StartBroadcast1 is a paid mutator transaction binding the contract method 0xce817d47.
+//
+// Solidity: function startBroadcast(uint256 privateKey) returns()
+func (_VmSafe *VmSafeTransactor) StartBroadcast1(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "startBroadcast1", privateKey)
+}
+
+// StartBroadcast1 is a paid mutator transaction binding the contract method 0xce817d47.
+//
+// Solidity: function startBroadcast(uint256 privateKey) returns()
+func (_VmSafe *VmSafeSession) StartBroadcast1(privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.StartBroadcast1(&_VmSafe.TransactOpts, privateKey)
+}
+
+// StartBroadcast1 is a paid mutator transaction binding the contract method 0xce817d47.
+//
+// Solidity: function startBroadcast(uint256 privateKey) returns()
+func (_VmSafe *VmSafeTransactorSession) StartBroadcast1(privateKey *big.Int) (*types.Transaction, error) {
+	return _VmSafe.Contract.StartBroadcast1(&_VmSafe.TransactOpts, privateKey)
+}
+
+// StartDebugTraceRecording is a paid mutator transaction binding the contract method 0x419c8832.
+//
+// Solidity: function startDebugTraceRecording() returns()
+func (_VmSafe *VmSafeTransactor) StartDebugTraceRecording(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "startDebugTraceRecording")
+}
+
+// StartDebugTraceRecording is a paid mutator transaction binding the contract method 0x419c8832.
+//
+// Solidity: function startDebugTraceRecording() returns()
+func (_VmSafe *VmSafeSession) StartDebugTraceRecording() (*types.Transaction, error) {
+	return _VmSafe.Contract.StartDebugTraceRecording(&_VmSafe.TransactOpts)
+}
+
+// StartDebugTraceRecording is a paid mutator transaction binding the contract method 0x419c8832.
+//
+// Solidity: function startDebugTraceRecording() returns()
+func (_VmSafe *VmSafeTransactorSession) StartDebugTraceRecording() (*types.Transaction, error) {
+	return _VmSafe.Contract.StartDebugTraceRecording(&_VmSafe.TransactOpts)
+}
+
+// StartMappingRecording is a paid mutator transaction binding the contract method 0x3e9705c0.
+//
+// Solidity: function startMappingRecording() returns()
+func (_VmSafe *VmSafeTransactor) StartMappingRecording(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "startMappingRecording")
+}
+
+// StartMappingRecording is a paid mutator transaction binding the contract method 0x3e9705c0.
+//
+// Solidity: function startMappingRecording() returns()
+func (_VmSafe *VmSafeSession) StartMappingRecording() (*types.Transaction, error) {
+	return _VmSafe.Contract.StartMappingRecording(&_VmSafe.TransactOpts)
+}
+
+// StartMappingRecording is a paid mutator transaction binding the contract method 0x3e9705c0.
+//
+// Solidity: function startMappingRecording() returns()
+func (_VmSafe *VmSafeTransactorSession) StartMappingRecording() (*types.Transaction, error) {
+	return _VmSafe.Contract.StartMappingRecording(&_VmSafe.TransactOpts)
+}
+
+// StartStateDiffRecording is a paid mutator transaction binding the contract method 0xcf22e3c9.
+//
+// Solidity: function startStateDiffRecording() returns()
+func (_VmSafe *VmSafeTransactor) StartStateDiffRecording(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "startStateDiffRecording")
+}
+
+// StartStateDiffRecording is a paid mutator transaction binding the contract method 0xcf22e3c9.
+//
+// Solidity: function startStateDiffRecording() returns()
+func (_VmSafe *VmSafeSession) StartStateDiffRecording() (*types.Transaction, error) {
+	return _VmSafe.Contract.StartStateDiffRecording(&_VmSafe.TransactOpts)
+}
+
+// StartStateDiffRecording is a paid mutator transaction binding the contract method 0xcf22e3c9.
+//
+// Solidity: function startStateDiffRecording() returns()
+func (_VmSafe *VmSafeTransactorSession) StartStateDiffRecording() (*types.Transaction, error) {
+	return _VmSafe.Contract.StartStateDiffRecording(&_VmSafe.TransactOpts)
+}
+
+// StopAndReturnDebugTraceRecording is a paid mutator transaction binding the contract method 0xced398a2.
+//
+// Solidity: function stopAndReturnDebugTraceRecording() returns((uint256[],bytes,uint8,uint64,bool,address)[] step)
+func (_VmSafe *VmSafeTransactor) StopAndReturnDebugTraceRecording(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "stopAndReturnDebugTraceRecording")
+}
+
+// StopAndReturnDebugTraceRecording is a paid mutator transaction binding the contract method 0xced398a2.
+//
+// Solidity: function stopAndReturnDebugTraceRecording() returns((uint256[],bytes,uint8,uint64,bool,address)[] step)
+func (_VmSafe *VmSafeSession) StopAndReturnDebugTraceRecording() (*types.Transaction, error) {
+	return _VmSafe.Contract.StopAndReturnDebugTraceRecording(&_VmSafe.TransactOpts)
+}
+
+// StopAndReturnDebugTraceRecording is a paid mutator transaction binding the contract method 0xced398a2.
+//
+// Solidity: function stopAndReturnDebugTraceRecording() returns((uint256[],bytes,uint8,uint64,bool,address)[] step)
+func (_VmSafe *VmSafeTransactorSession) StopAndReturnDebugTraceRecording() (*types.Transaction, error) {
+	return _VmSafe.Contract.StopAndReturnDebugTraceRecording(&_VmSafe.TransactOpts)
+}
+
+// StopAndReturnStateDiff is a paid mutator transaction binding the contract method 0xaa5cf90e.
+//
+// Solidity: function stopAndReturnStateDiff() returns(((uint256,uint256),uint8,address,address,bool,uint256,uint256,bytes,uint256,bytes,bool,(address,bytes32,bool,bytes32,bytes32,bool)[],uint64)[] accountAccesses)
+func (_VmSafe *VmSafeTransactor) StopAndReturnStateDiff(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "stopAndReturnStateDiff")
+}
+
+// StopAndReturnStateDiff is a paid mutator transaction binding the contract method 0xaa5cf90e.
+//
+// Solidity: function stopAndReturnStateDiff() returns(((uint256,uint256),uint8,address,address,bool,uint256,uint256,bytes,uint256,bytes,bool,(address,bytes32,bool,bytes32,bytes32,bool)[],uint64)[] accountAccesses)
+func (_VmSafe *VmSafeSession) StopAndReturnStateDiff() (*types.Transaction, error) {
+	return _VmSafe.Contract.StopAndReturnStateDiff(&_VmSafe.TransactOpts)
+}
+
+// StopAndReturnStateDiff is a paid mutator transaction binding the contract method 0xaa5cf90e.
+//
+// Solidity: function stopAndReturnStateDiff() returns(((uint256,uint256),uint8,address,address,bool,uint256,uint256,bytes,uint256,bytes,bool,(address,bytes32,bool,bytes32,bytes32,bool)[],uint64)[] accountAccesses)
+func (_VmSafe *VmSafeTransactorSession) StopAndReturnStateDiff() (*types.Transaction, error) {
+	return _VmSafe.Contract.StopAndReturnStateDiff(&_VmSafe.TransactOpts)
+}
+
+// StopBroadcast is a paid mutator transaction binding the contract method 0x76eadd36.
+//
+// Solidity: function stopBroadcast() returns()
+func (_VmSafe *VmSafeTransactor) StopBroadcast(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "stopBroadcast")
+}
+
+// StopBroadcast is a paid mutator transaction binding the contract method 0x76eadd36.
+//
+// Solidity: function stopBroadcast() returns()
+func (_VmSafe *VmSafeSession) StopBroadcast() (*types.Transaction, error) {
+	return _VmSafe.Contract.StopBroadcast(&_VmSafe.TransactOpts)
+}
+
+// StopBroadcast is a paid mutator transaction binding the contract method 0x76eadd36.
+//
+// Solidity: function stopBroadcast() returns()
+func (_VmSafe *VmSafeTransactorSession) StopBroadcast() (*types.Transaction, error) {
+	return _VmSafe.Contract.StopBroadcast(&_VmSafe.TransactOpts)
+}
+
+// StopMappingRecording is a paid mutator transaction binding the contract method 0x0d4aae9b.
+//
+// Solidity: function stopMappingRecording() returns()
+func (_VmSafe *VmSafeTransactor) StopMappingRecording(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "stopMappingRecording")
+}
+
+// StopMappingRecording is a paid mutator transaction binding the contract method 0x0d4aae9b.
+//
+// Solidity: function stopMappingRecording() returns()
+func (_VmSafe *VmSafeSession) StopMappingRecording() (*types.Transaction, error) {
+	return _VmSafe.Contract.StopMappingRecording(&_VmSafe.TransactOpts)
+}
+
+// StopMappingRecording is a paid mutator transaction binding the contract method 0x0d4aae9b.
+//
+// Solidity: function stopMappingRecording() returns()
+func (_VmSafe *VmSafeTransactorSession) StopMappingRecording() (*types.Transaction, error) {
+	return _VmSafe.Contract.StopMappingRecording(&_VmSafe.TransactOpts)
+}
+
+// TryFfi is a paid mutator transaction binding the contract method 0xf45c1ce7.
+//
+// Solidity: function tryFfi(string[] commandInput) returns((int32,bytes,bytes) result)
+func (_VmSafe *VmSafeTransactor) TryFfi(opts *bind.TransactOpts, commandInput []string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "tryFfi", commandInput)
+}
+
+// TryFfi is a paid mutator transaction binding the contract method 0xf45c1ce7.
+//
+// Solidity: function tryFfi(string[] commandInput) returns((int32,bytes,bytes) result)
+func (_VmSafe *VmSafeSession) TryFfi(commandInput []string) (*types.Transaction, error) {
+	return _VmSafe.Contract.TryFfi(&_VmSafe.TransactOpts, commandInput)
+}
+
+// TryFfi is a paid mutator transaction binding the contract method 0xf45c1ce7.
+//
+// Solidity: function tryFfi(string[] commandInput) returns((int32,bytes,bytes) result)
+func (_VmSafe *VmSafeTransactorSession) TryFfi(commandInput []string) (*types.Transaction, error) {
+	return _VmSafe.Contract.TryFfi(&_VmSafe.TransactOpts, commandInput)
+}
+
+// WriteFile is a paid mutator transaction binding the contract method 0x897e0a97.
+//
+// Solidity: function writeFile(string path, string data) returns()
+func (_VmSafe *VmSafeTransactor) WriteFile(opts *bind.TransactOpts, path string, data string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "writeFile", path, data)
+}
+
+// WriteFile is a paid mutator transaction binding the contract method 0x897e0a97.
+//
+// Solidity: function writeFile(string path, string data) returns()
+func (_VmSafe *VmSafeSession) WriteFile(path string, data string) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteFile(&_VmSafe.TransactOpts, path, data)
+}
+
+// WriteFile is a paid mutator transaction binding the contract method 0x897e0a97.
+//
+// Solidity: function writeFile(string path, string data) returns()
+func (_VmSafe *VmSafeTransactorSession) WriteFile(path string, data string) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteFile(&_VmSafe.TransactOpts, path, data)
+}
+
+// WriteFileBinary is a paid mutator transaction binding the contract method 0x1f21fc80.
+//
+// Solidity: function writeFileBinary(string path, bytes data) returns()
+func (_VmSafe *VmSafeTransactor) WriteFileBinary(opts *bind.TransactOpts, path string, data []byte) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "writeFileBinary", path, data)
+}
+
+// WriteFileBinary is a paid mutator transaction binding the contract method 0x1f21fc80.
+//
+// Solidity: function writeFileBinary(string path, bytes data) returns()
+func (_VmSafe *VmSafeSession) WriteFileBinary(path string, data []byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteFileBinary(&_VmSafe.TransactOpts, path, data)
+}
+
+// WriteFileBinary is a paid mutator transaction binding the contract method 0x1f21fc80.
+//
+// Solidity: function writeFileBinary(string path, bytes data) returns()
+func (_VmSafe *VmSafeTransactorSession) WriteFileBinary(path string, data []byte) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteFileBinary(&_VmSafe.TransactOpts, path, data)
+}
+
+// WriteJson is a paid mutator transaction binding the contract method 0x35d6ad46.
+//
+// Solidity: function writeJson(string json, string path, string valueKey) returns()
+func (_VmSafe *VmSafeTransactor) WriteJson(opts *bind.TransactOpts, json string, path string, valueKey string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "writeJson", json, path, valueKey)
+}
+
+// WriteJson is a paid mutator transaction binding the contract method 0x35d6ad46.
+//
+// Solidity: function writeJson(string json, string path, string valueKey) returns()
+func (_VmSafe *VmSafeSession) WriteJson(json string, path string, valueKey string) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteJson(&_VmSafe.TransactOpts, json, path, valueKey)
+}
+
+// WriteJson is a paid mutator transaction binding the contract method 0x35d6ad46.
+//
+// Solidity: function writeJson(string json, string path, string valueKey) returns()
+func (_VmSafe *VmSafeTransactorSession) WriteJson(json string, path string, valueKey string) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteJson(&_VmSafe.TransactOpts, json, path, valueKey)
+}
+
+// WriteJson0 is a paid mutator transaction binding the contract method 0xe23cd19f.
+//
+// Solidity: function writeJson(string json, string path) returns()
+func (_VmSafe *VmSafeTransactor) WriteJson0(opts *bind.TransactOpts, json string, path string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "writeJson0", json, path)
+}
+
+// WriteJson0 is a paid mutator transaction binding the contract method 0xe23cd19f.
+//
+// Solidity: function writeJson(string json, string path) returns()
+func (_VmSafe *VmSafeSession) WriteJson0(json string, path string) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteJson0(&_VmSafe.TransactOpts, json, path)
+}
+
+// WriteJson0 is a paid mutator transaction binding the contract method 0xe23cd19f.
+//
+// Solidity: function writeJson(string json, string path) returns()
+func (_VmSafe *VmSafeTransactorSession) WriteJson0(json string, path string) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteJson0(&_VmSafe.TransactOpts, json, path)
+}
+
+// WriteLine is a paid mutator transaction binding the contract method 0x619d897f.
+//
+// Solidity: function writeLine(string path, string data) returns()
+func (_VmSafe *VmSafeTransactor) WriteLine(opts *bind.TransactOpts, path string, data string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "writeLine", path, data)
+}
+
+// WriteLine is a paid mutator transaction binding the contract method 0x619d897f.
+//
+// Solidity: function writeLine(string path, string data) returns()
+func (_VmSafe *VmSafeSession) WriteLine(path string, data string) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteLine(&_VmSafe.TransactOpts, path, data)
+}
+
+// WriteLine is a paid mutator transaction binding the contract method 0x619d897f.
+//
+// Solidity: function writeLine(string path, string data) returns()
+func (_VmSafe *VmSafeTransactorSession) WriteLine(path string, data string) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteLine(&_VmSafe.TransactOpts, path, data)
+}
+
+// WriteToml is a paid mutator transaction binding the contract method 0x51ac6a33.
+//
+// Solidity: function writeToml(string json, string path, string valueKey) returns()
+func (_VmSafe *VmSafeTransactor) WriteToml(opts *bind.TransactOpts, json string, path string, valueKey string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "writeToml", json, path, valueKey)
+}
+
+// WriteToml is a paid mutator transaction binding the contract method 0x51ac6a33.
+//
+// Solidity: function writeToml(string json, string path, string valueKey) returns()
+func (_VmSafe *VmSafeSession) WriteToml(json string, path string, valueKey string) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteToml(&_VmSafe.TransactOpts, json, path, valueKey)
+}
+
+// WriteToml is a paid mutator transaction binding the contract method 0x51ac6a33.
+//
+// Solidity: function writeToml(string json, string path, string valueKey) returns()
+func (_VmSafe *VmSafeTransactorSession) WriteToml(json string, path string, valueKey string) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteToml(&_VmSafe.TransactOpts, json, path, valueKey)
+}
+
+// WriteToml0 is a paid mutator transaction binding the contract method 0xc0865ba7.
+//
+// Solidity: function writeToml(string json, string path) returns()
+func (_VmSafe *VmSafeTransactor) WriteToml0(opts *bind.TransactOpts, json string, path string) (*types.Transaction, error) {
+	return _VmSafe.contract.Transact(opts, "writeToml0", json, path)
+}
+
+// WriteToml0 is a paid mutator transaction binding the contract method 0xc0865ba7.
+//
+// Solidity: function writeToml(string json, string path) returns()
+func (_VmSafe *VmSafeSession) WriteToml0(json string, path string) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteToml0(&_VmSafe.TransactOpts, json, path)
+}
+
+// WriteToml0 is a paid mutator transaction binding the contract method 0xc0865ba7.
+//
+// Solidity: function writeToml(string json, string path) returns()
+func (_VmSafe *VmSafeTransactorSession) WriteToml0(json string, path string) (*types.Transaction, error) {
+	return _VmSafe.Contract.WriteToml0(&_VmSafe.TransactOpts, json, path)
+}
+
+// X509CRLHelperMetaData contains all meta data concerning the X509CRLHelper contract.
+var X509CRLHelperMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"crlIsNotExpired\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isValid\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getIssuerCommonName\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"issuerCommonName\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getSerialNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"serialNum\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getTbsAndSig\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"tbs\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"sig\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"parseCRLDER\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"serialNumber\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"issuerCommonName\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"validityNotBefore\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"validityNotAfter\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"serialNumbersRevoked\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"tbs\",\"type\":\"bytes\"}],\"internalType\":\"structX509CRLObj\",\"name\":\"crl\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"serialNumber\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"serialNumberIsRevoked\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"revoked\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
+	Bin: "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",
+}
+
+// X509CRLHelperABI is the input ABI used to generate the binding from.
+// Deprecated: Use X509CRLHelperMetaData.ABI instead.
+var X509CRLHelperABI = X509CRLHelperMetaData.ABI
+
+// X509CRLHelperBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use X509CRLHelperMetaData.Bin instead.
+var X509CRLHelperBin = X509CRLHelperMetaData.Bin
+
+// DeployX509CRLHelper deploys a new Ethereum contract, binding an instance of X509CRLHelper to it.
+func DeployX509CRLHelper(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *X509CRLHelper, error) {
+	parsed, err := X509CRLHelperMetaData.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(X509CRLHelperBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &X509CRLHelper{X509CRLHelperCaller: X509CRLHelperCaller{contract: contract}, X509CRLHelperTransactor: X509CRLHelperTransactor{contract: contract}, X509CRLHelperFilterer: X509CRLHelperFilterer{contract: contract}}, nil
+}
+
+// X509CRLHelper is an auto generated Go binding around an Ethereum contract.
+type X509CRLHelper struct {
+	X509CRLHelperCaller     // Read-only binding to the contract
+	X509CRLHelperTransactor // Write-only binding to the contract
+	X509CRLHelperFilterer   // Log filterer for contract events
+}
+
+// X509CRLHelperCaller is an auto generated read-only Go binding around an Ethereum contract.
+type X509CRLHelperCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// X509CRLHelperTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type X509CRLHelperTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// X509CRLHelperFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type X509CRLHelperFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// X509CRLHelperSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type X509CRLHelperSession struct {
+	Contract     *X509CRLHelper    // 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
+}
+
+// X509CRLHelperCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type X509CRLHelperCallerSession struct {
+	Contract *X509CRLHelperCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts        // Call options to use throughout this session
+}
+
+// X509CRLHelperTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type X509CRLHelperTransactorSession struct {
+	Contract     *X509CRLHelperTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
+}
+
+// X509CRLHelperRaw is an auto generated low-level Go binding around an Ethereum contract.
+type X509CRLHelperRaw struct {
+	Contract *X509CRLHelper // Generic contract binding to access the raw methods on
+}
+
+// X509CRLHelperCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type X509CRLHelperCallerRaw struct {
+	Contract *X509CRLHelperCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// X509CRLHelperTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type X509CRLHelperTransactorRaw struct {
+	Contract *X509CRLHelperTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewX509CRLHelper creates a new instance of X509CRLHelper, bound to a specific deployed contract.
+func NewX509CRLHelper(address common.Address, backend bind.ContractBackend) (*X509CRLHelper, error) {
+	contract, err := bindX509CRLHelper(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &X509CRLHelper{X509CRLHelperCaller: X509CRLHelperCaller{contract: contract}, X509CRLHelperTransactor: X509CRLHelperTransactor{contract: contract}, X509CRLHelperFilterer: X509CRLHelperFilterer{contract: contract}}, nil
+}
+
+// NewX509CRLHelperCaller creates a new read-only instance of X509CRLHelper, bound to a specific deployed contract.
+func NewX509CRLHelperCaller(address common.Address, caller bind.ContractCaller) (*X509CRLHelperCaller, error) {
+	contract, err := bindX509CRLHelper(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &X509CRLHelperCaller{contract: contract}, nil
+}
+
+// NewX509CRLHelperTransactor creates a new write-only instance of X509CRLHelper, bound to a specific deployed contract.
+func NewX509CRLHelperTransactor(address common.Address, transactor bind.ContractTransactor) (*X509CRLHelperTransactor, error) {
+	contract, err := bindX509CRLHelper(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &X509CRLHelperTransactor{contract: contract}, nil
+}
+
+// NewX509CRLHelperFilterer creates a new log filterer instance of X509CRLHelper, bound to a specific deployed contract.
+func NewX509CRLHelperFilterer(address common.Address, filterer bind.ContractFilterer) (*X509CRLHelperFilterer, error) {
+	contract, err := bindX509CRLHelper(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &X509CRLHelperFilterer{contract: contract}, nil
+}
+
+// bindX509CRLHelper binds a generic wrapper to an already deployed contract.
+func bindX509CRLHelper(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := X509CRLHelperMetaData.GetAbi()
+	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 (_X509CRLHelper *X509CRLHelperRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _X509CRLHelper.Contract.X509CRLHelperCaller.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 (_X509CRLHelper *X509CRLHelperRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _X509CRLHelper.Contract.X509CRLHelperTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_X509CRLHelper *X509CRLHelperRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _X509CRLHelper.Contract.X509CRLHelperTransactor.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 (_X509CRLHelper *X509CRLHelperCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _X509CRLHelper.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 (_X509CRLHelper *X509CRLHelperTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _X509CRLHelper.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_X509CRLHelper *X509CRLHelperTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _X509CRLHelper.Contract.contract.Transact(opts, method, params...)
+}
+
+// CrlIsNotExpired is a free data retrieval call binding the contract method 0xa91105ce.
+//
+// Solidity: function crlIsNotExpired(bytes der) view returns(bool isValid)
+func (_X509CRLHelper *X509CRLHelperCaller) CrlIsNotExpired(opts *bind.CallOpts, der []byte) (bool, error) {
+	var out []interface{}
+	err := _X509CRLHelper.contract.Call(opts, &out, "crlIsNotExpired", der)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// CrlIsNotExpired is a free data retrieval call binding the contract method 0xa91105ce.
+//
+// Solidity: function crlIsNotExpired(bytes der) view returns(bool isValid)
+func (_X509CRLHelper *X509CRLHelperSession) CrlIsNotExpired(der []byte) (bool, error) {
+	return _X509CRLHelper.Contract.CrlIsNotExpired(&_X509CRLHelper.CallOpts, der)
+}
+
+// CrlIsNotExpired is a free data retrieval call binding the contract method 0xa91105ce.
+//
+// Solidity: function crlIsNotExpired(bytes der) view returns(bool isValid)
+func (_X509CRLHelper *X509CRLHelperCallerSession) CrlIsNotExpired(der []byte) (bool, error) {
+	return _X509CRLHelper.Contract.CrlIsNotExpired(&_X509CRLHelper.CallOpts, der)
+}
+
+// GetIssuerCommonName is a free data retrieval call binding the contract method 0x634fdad5.
+//
+// Solidity: function getIssuerCommonName(bytes der) pure returns(string issuerCommonName)
+func (_X509CRLHelper *X509CRLHelperCaller) GetIssuerCommonName(opts *bind.CallOpts, der []byte) (string, error) {
+	var out []interface{}
+	err := _X509CRLHelper.contract.Call(opts, &out, "getIssuerCommonName", der)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetIssuerCommonName is a free data retrieval call binding the contract method 0x634fdad5.
+//
+// Solidity: function getIssuerCommonName(bytes der) pure returns(string issuerCommonName)
+func (_X509CRLHelper *X509CRLHelperSession) GetIssuerCommonName(der []byte) (string, error) {
+	return _X509CRLHelper.Contract.GetIssuerCommonName(&_X509CRLHelper.CallOpts, der)
+}
+
+// GetIssuerCommonName is a free data retrieval call binding the contract method 0x634fdad5.
+//
+// Solidity: function getIssuerCommonName(bytes der) pure returns(string issuerCommonName)
+func (_X509CRLHelper *X509CRLHelperCallerSession) GetIssuerCommonName(der []byte) (string, error) {
+	return _X509CRLHelper.Contract.GetIssuerCommonName(&_X509CRLHelper.CallOpts, der)
+}
+
+// GetSerialNumber is a free data retrieval call binding the contract method 0xb29b51cb.
+//
+// Solidity: function getSerialNumber(bytes der) pure returns(uint256 serialNum)
+func (_X509CRLHelper *X509CRLHelperCaller) GetSerialNumber(opts *bind.CallOpts, der []byte) (*big.Int, error) {
+	var out []interface{}
+	err := _X509CRLHelper.contract.Call(opts, &out, "getSerialNumber", der)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetSerialNumber is a free data retrieval call binding the contract method 0xb29b51cb.
+//
+// Solidity: function getSerialNumber(bytes der) pure returns(uint256 serialNum)
+func (_X509CRLHelper *X509CRLHelperSession) GetSerialNumber(der []byte) (*big.Int, error) {
+	return _X509CRLHelper.Contract.GetSerialNumber(&_X509CRLHelper.CallOpts, der)
+}
+
+// GetSerialNumber is a free data retrieval call binding the contract method 0xb29b51cb.
+//
+// Solidity: function getSerialNumber(bytes der) pure returns(uint256 serialNum)
+func (_X509CRLHelper *X509CRLHelperCallerSession) GetSerialNumber(der []byte) (*big.Int, error) {
+	return _X509CRLHelper.Contract.GetSerialNumber(&_X509CRLHelper.CallOpts, der)
+}
+
+// GetTbsAndSig is a free data retrieval call binding the contract method 0xfcf0be24.
+//
+// Solidity: function getTbsAndSig(bytes der) pure returns(bytes tbs, bytes sig)
+func (_X509CRLHelper *X509CRLHelperCaller) GetTbsAndSig(opts *bind.CallOpts, der []byte) (struct {
+	Tbs []byte
+	Sig []byte
+}, error) {
+	var out []interface{}
+	err := _X509CRLHelper.contract.Call(opts, &out, "getTbsAndSig", der)
+
+	outstruct := new(struct {
+		Tbs []byte
+		Sig []byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.Tbs = *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+	outstruct.Sig = *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return *outstruct, err
+
+}
+
+// GetTbsAndSig is a free data retrieval call binding the contract method 0xfcf0be24.
+//
+// Solidity: function getTbsAndSig(bytes der) pure returns(bytes tbs, bytes sig)
+func (_X509CRLHelper *X509CRLHelperSession) GetTbsAndSig(der []byte) (struct {
+	Tbs []byte
+	Sig []byte
+}, error) {
+	return _X509CRLHelper.Contract.GetTbsAndSig(&_X509CRLHelper.CallOpts, der)
+}
+
+// GetTbsAndSig is a free data retrieval call binding the contract method 0xfcf0be24.
+//
+// Solidity: function getTbsAndSig(bytes der) pure returns(bytes tbs, bytes sig)
+func (_X509CRLHelper *X509CRLHelperCallerSession) GetTbsAndSig(der []byte) (struct {
+	Tbs []byte
+	Sig []byte
+}, error) {
+	return _X509CRLHelper.Contract.GetTbsAndSig(&_X509CRLHelper.CallOpts, der)
+}
+
+// ParseCRLDER is a free data retrieval call binding the contract method 0x01cd975b.
+//
+// Solidity: function parseCRLDER(bytes der) pure returns((uint256,string,uint256,uint256,uint256[],bytes,bytes) crl)
+func (_X509CRLHelper *X509CRLHelperCaller) ParseCRLDER(opts *bind.CallOpts, der []byte) (X509CRLObj, error) {
+	var out []interface{}
+	err := _X509CRLHelper.contract.Call(opts, &out, "parseCRLDER", der)
+
+	if err != nil {
+		return *new(X509CRLObj), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(X509CRLObj)).(*X509CRLObj)
+
+	return out0, err
+
+}
+
+// ParseCRLDER is a free data retrieval call binding the contract method 0x01cd975b.
+//
+// Solidity: function parseCRLDER(bytes der) pure returns((uint256,string,uint256,uint256,uint256[],bytes,bytes) crl)
+func (_X509CRLHelper *X509CRLHelperSession) ParseCRLDER(der []byte) (X509CRLObj, error) {
+	return _X509CRLHelper.Contract.ParseCRLDER(&_X509CRLHelper.CallOpts, der)
+}
+
+// ParseCRLDER is a free data retrieval call binding the contract method 0x01cd975b.
+//
+// Solidity: function parseCRLDER(bytes der) pure returns((uint256,string,uint256,uint256,uint256[],bytes,bytes) crl)
+func (_X509CRLHelper *X509CRLHelperCallerSession) ParseCRLDER(der []byte) (X509CRLObj, error) {
+	return _X509CRLHelper.Contract.ParseCRLDER(&_X509CRLHelper.CallOpts, der)
+}
+
+// SerialNumberIsRevoked is a free data retrieval call binding the contract method 0xcedb9781.
+//
+// Solidity: function serialNumberIsRevoked(uint256 serialNumber, bytes der) pure returns(bool revoked)
+func (_X509CRLHelper *X509CRLHelperCaller) SerialNumberIsRevoked(opts *bind.CallOpts, serialNumber *big.Int, der []byte) (bool, error) {
+	var out []interface{}
+	err := _X509CRLHelper.contract.Call(opts, &out, "serialNumberIsRevoked", serialNumber, der)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// SerialNumberIsRevoked is a free data retrieval call binding the contract method 0xcedb9781.
+//
+// Solidity: function serialNumberIsRevoked(uint256 serialNumber, bytes der) pure returns(bool revoked)
+func (_X509CRLHelper *X509CRLHelperSession) SerialNumberIsRevoked(serialNumber *big.Int, der []byte) (bool, error) {
+	return _X509CRLHelper.Contract.SerialNumberIsRevoked(&_X509CRLHelper.CallOpts, serialNumber, der)
+}
+
+// SerialNumberIsRevoked is a free data retrieval call binding the contract method 0xcedb9781.
+//
+// Solidity: function serialNumberIsRevoked(uint256 serialNumber, bytes der) pure returns(bool revoked)
+func (_X509CRLHelper *X509CRLHelperCallerSession) SerialNumberIsRevoked(serialNumber *big.Int, der []byte) (bool, error) {
+	return _X509CRLHelper.Contract.SerialNumberIsRevoked(&_X509CRLHelper.CallOpts, serialNumber, der)
+}
+
+// X509ChainBaseMetaData contains all meta data concerning the X509ChainBase contract.
+var X509ChainBaseMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"P256_VERIFIER\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+}
+
+// X509ChainBaseABI is the input ABI used to generate the binding from.
+// Deprecated: Use X509ChainBaseMetaData.ABI instead.
+var X509ChainBaseABI = X509ChainBaseMetaData.ABI
+
+// X509ChainBase is an auto generated Go binding around an Ethereum contract.
+type X509ChainBase struct {
+	X509ChainBaseCaller     // Read-only binding to the contract
+	X509ChainBaseTransactor // Write-only binding to the contract
+	X509ChainBaseFilterer   // Log filterer for contract events
+}
+
+// X509ChainBaseCaller is an auto generated read-only Go binding around an Ethereum contract.
+type X509ChainBaseCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// X509ChainBaseTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type X509ChainBaseTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// X509ChainBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type X509ChainBaseFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// X509ChainBaseSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type X509ChainBaseSession struct {
+	Contract     *X509ChainBase    // 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
+}
+
+// X509ChainBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type X509ChainBaseCallerSession struct {
+	Contract *X509ChainBaseCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts        // Call options to use throughout this session
+}
+
+// X509ChainBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type X509ChainBaseTransactorSession struct {
+	Contract     *X509ChainBaseTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
+}
+
+// X509ChainBaseRaw is an auto generated low-level Go binding around an Ethereum contract.
+type X509ChainBaseRaw struct {
+	Contract *X509ChainBase // Generic contract binding to access the raw methods on
+}
+
+// X509ChainBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type X509ChainBaseCallerRaw struct {
+	Contract *X509ChainBaseCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// X509ChainBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type X509ChainBaseTransactorRaw struct {
+	Contract *X509ChainBaseTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewX509ChainBase creates a new instance of X509ChainBase, bound to a specific deployed contract.
+func NewX509ChainBase(address common.Address, backend bind.ContractBackend) (*X509ChainBase, error) {
+	contract, err := bindX509ChainBase(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &X509ChainBase{X509ChainBaseCaller: X509ChainBaseCaller{contract: contract}, X509ChainBaseTransactor: X509ChainBaseTransactor{contract: contract}, X509ChainBaseFilterer: X509ChainBaseFilterer{contract: contract}}, nil
+}
+
+// NewX509ChainBaseCaller creates a new read-only instance of X509ChainBase, bound to a specific deployed contract.
+func NewX509ChainBaseCaller(address common.Address, caller bind.ContractCaller) (*X509ChainBaseCaller, error) {
+	contract, err := bindX509ChainBase(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &X509ChainBaseCaller{contract: contract}, nil
+}
+
+// NewX509ChainBaseTransactor creates a new write-only instance of X509ChainBase, bound to a specific deployed contract.
+func NewX509ChainBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*X509ChainBaseTransactor, error) {
+	contract, err := bindX509ChainBase(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &X509ChainBaseTransactor{contract: contract}, nil
+}
+
+// NewX509ChainBaseFilterer creates a new log filterer instance of X509ChainBase, bound to a specific deployed contract.
+func NewX509ChainBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*X509ChainBaseFilterer, error) {
+	contract, err := bindX509ChainBase(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &X509ChainBaseFilterer{contract: contract}, nil
+}
+
+// bindX509ChainBase binds a generic wrapper to an already deployed contract.
+func bindX509ChainBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := X509ChainBaseMetaData.GetAbi()
+	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 (_X509ChainBase *X509ChainBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _X509ChainBase.Contract.X509ChainBaseCaller.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 (_X509ChainBase *X509ChainBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _X509ChainBase.Contract.X509ChainBaseTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_X509ChainBase *X509ChainBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _X509ChainBase.Contract.X509ChainBaseTransactor.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 (_X509ChainBase *X509ChainBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _X509ChainBase.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 (_X509ChainBase *X509ChainBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _X509ChainBase.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_X509ChainBase *X509ChainBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _X509ChainBase.Contract.contract.Transact(opts, method, params...)
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_X509ChainBase *X509ChainBaseCaller) P256VERIFIER(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _X509ChainBase.contract.Call(opts, &out, "P256_VERIFIER")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_X509ChainBase *X509ChainBaseSession) P256VERIFIER() (common.Address, error) {
+	return _X509ChainBase.Contract.P256VERIFIER(&_X509ChainBase.CallOpts)
+}
+
+// P256VERIFIER is a free data retrieval call binding the contract method 0x536c633d.
+//
+// Solidity: function P256_VERIFIER() view returns(address)
+func (_X509ChainBase *X509ChainBaseCallerSession) P256VERIFIER() (common.Address, error) {
+	return _X509ChainBase.Contract.P256VERIFIER(&_X509ChainBase.CallOpts)
+}
+
+// X509HelperMetaData contains all meta data concerning the X509Helper contract.
+var X509HelperMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"certIsNotExpired\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isValid\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getIssuerCommonName\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"issuerCommonName\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getSerialNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"serialNum\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getSubjectCommonName\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"subjectCommonName\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getSubjectPublicKey\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"pubKey\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"getTbsAndSig\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"tbs\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"sig\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"der\",\"type\":\"bytes\"}],\"name\":\"parseX509DER\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"serialNumber\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"issuerCommonName\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"validityNotBefore\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"validityNotAfter\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"subjectCommonName\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"subjectPublicKey\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"extensionPtr\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"tbs\",\"type\":\"bytes\"}],\"internalType\":\"structX509CertObj\",\"name\":\"cert\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
+	Bin: "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",
+}
+
+// X509HelperABI is the input ABI used to generate the binding from.
+// Deprecated: Use X509HelperMetaData.ABI instead.
+var X509HelperABI = X509HelperMetaData.ABI
+
+// X509HelperBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use X509HelperMetaData.Bin instead.
+var X509HelperBin = X509HelperMetaData.Bin
+
+// DeployX509Helper deploys a new Ethereum contract, binding an instance of X509Helper to it.
+func DeployX509Helper(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *X509Helper, error) {
+	parsed, err := X509HelperMetaData.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(X509HelperBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &X509Helper{X509HelperCaller: X509HelperCaller{contract: contract}, X509HelperTransactor: X509HelperTransactor{contract: contract}, X509HelperFilterer: X509HelperFilterer{contract: contract}}, nil
+}
+
+// X509Helper is an auto generated Go binding around an Ethereum contract.
+type X509Helper struct {
+	X509HelperCaller     // Read-only binding to the contract
+	X509HelperTransactor // Write-only binding to the contract
+	X509HelperFilterer   // Log filterer for contract events
+}
+
+// X509HelperCaller is an auto generated read-only Go binding around an Ethereum contract.
+type X509HelperCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// X509HelperTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type X509HelperTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// X509HelperFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type X509HelperFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// X509HelperSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type X509HelperSession struct {
+	Contract     *X509Helper       // 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
+}
+
+// X509HelperCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type X509HelperCallerSession struct {
+	Contract *X509HelperCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts     // Call options to use throughout this session
+}
+
+// X509HelperTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type X509HelperTransactorSession struct {
+	Contract     *X509HelperTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
+}
+
+// X509HelperRaw is an auto generated low-level Go binding around an Ethereum contract.
+type X509HelperRaw struct {
+	Contract *X509Helper // Generic contract binding to access the raw methods on
+}
+
+// X509HelperCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type X509HelperCallerRaw struct {
+	Contract *X509HelperCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// X509HelperTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type X509HelperTransactorRaw struct {
+	Contract *X509HelperTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewX509Helper creates a new instance of X509Helper, bound to a specific deployed contract.
+func NewX509Helper(address common.Address, backend bind.ContractBackend) (*X509Helper, error) {
+	contract, err := bindX509Helper(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &X509Helper{X509HelperCaller: X509HelperCaller{contract: contract}, X509HelperTransactor: X509HelperTransactor{contract: contract}, X509HelperFilterer: X509HelperFilterer{contract: contract}}, nil
+}
+
+// NewX509HelperCaller creates a new read-only instance of X509Helper, bound to a specific deployed contract.
+func NewX509HelperCaller(address common.Address, caller bind.ContractCaller) (*X509HelperCaller, error) {
+	contract, err := bindX509Helper(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &X509HelperCaller{contract: contract}, nil
+}
+
+// NewX509HelperTransactor creates a new write-only instance of X509Helper, bound to a specific deployed contract.
+func NewX509HelperTransactor(address common.Address, transactor bind.ContractTransactor) (*X509HelperTransactor, error) {
+	contract, err := bindX509Helper(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &X509HelperTransactor{contract: contract}, nil
+}
+
+// NewX509HelperFilterer creates a new log filterer instance of X509Helper, bound to a specific deployed contract.
+func NewX509HelperFilterer(address common.Address, filterer bind.ContractFilterer) (*X509HelperFilterer, error) {
+	contract, err := bindX509Helper(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &X509HelperFilterer{contract: contract}, nil
+}
+
+// bindX509Helper binds a generic wrapper to an already deployed contract.
+func bindX509Helper(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := X509HelperMetaData.GetAbi()
+	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 (_X509Helper *X509HelperRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _X509Helper.Contract.X509HelperCaller.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 (_X509Helper *X509HelperRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _X509Helper.Contract.X509HelperTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_X509Helper *X509HelperRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _X509Helper.Contract.X509HelperTransactor.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 (_X509Helper *X509HelperCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _X509Helper.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 (_X509Helper *X509HelperTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _X509Helper.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_X509Helper *X509HelperTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _X509Helper.Contract.contract.Transact(opts, method, params...)
+}
+
+// CertIsNotExpired is a free data retrieval call binding the contract method 0xed333785.
+//
+// Solidity: function certIsNotExpired(bytes der) view returns(bool isValid)
+func (_X509Helper *X509HelperCaller) CertIsNotExpired(opts *bind.CallOpts, der []byte) (bool, error) {
+	var out []interface{}
+	err := _X509Helper.contract.Call(opts, &out, "certIsNotExpired", der)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// CertIsNotExpired is a free data retrieval call binding the contract method 0xed333785.
+//
+// Solidity: function certIsNotExpired(bytes der) view returns(bool isValid)
+func (_X509Helper *X509HelperSession) CertIsNotExpired(der []byte) (bool, error) {
+	return _X509Helper.Contract.CertIsNotExpired(&_X509Helper.CallOpts, der)
+}
+
+// CertIsNotExpired is a free data retrieval call binding the contract method 0xed333785.
+//
+// Solidity: function certIsNotExpired(bytes der) view returns(bool isValid)
+func (_X509Helper *X509HelperCallerSession) CertIsNotExpired(der []byte) (bool, error) {
+	return _X509Helper.Contract.CertIsNotExpired(&_X509Helper.CallOpts, der)
+}
+
+// GetIssuerCommonName is a free data retrieval call binding the contract method 0x634fdad5.
+//
+// Solidity: function getIssuerCommonName(bytes der) pure returns(string issuerCommonName)
+func (_X509Helper *X509HelperCaller) GetIssuerCommonName(opts *bind.CallOpts, der []byte) (string, error) {
+	var out []interface{}
+	err := _X509Helper.contract.Call(opts, &out, "getIssuerCommonName", der)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetIssuerCommonName is a free data retrieval call binding the contract method 0x634fdad5.
+//
+// Solidity: function getIssuerCommonName(bytes der) pure returns(string issuerCommonName)
+func (_X509Helper *X509HelperSession) GetIssuerCommonName(der []byte) (string, error) {
+	return _X509Helper.Contract.GetIssuerCommonName(&_X509Helper.CallOpts, der)
+}
+
+// GetIssuerCommonName is a free data retrieval call binding the contract method 0x634fdad5.
+//
+// Solidity: function getIssuerCommonName(bytes der) pure returns(string issuerCommonName)
+func (_X509Helper *X509HelperCallerSession) GetIssuerCommonName(der []byte) (string, error) {
+	return _X509Helper.Contract.GetIssuerCommonName(&_X509Helper.CallOpts, der)
+}
+
+// GetSerialNumber is a free data retrieval call binding the contract method 0xb29b51cb.
+//
+// Solidity: function getSerialNumber(bytes der) pure returns(uint256 serialNum)
+func (_X509Helper *X509HelperCaller) GetSerialNumber(opts *bind.CallOpts, der []byte) (*big.Int, error) {
+	var out []interface{}
+	err := _X509Helper.contract.Call(opts, &out, "getSerialNumber", der)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// GetSerialNumber is a free data retrieval call binding the contract method 0xb29b51cb.
+//
+// Solidity: function getSerialNumber(bytes der) pure returns(uint256 serialNum)
+func (_X509Helper *X509HelperSession) GetSerialNumber(der []byte) (*big.Int, error) {
+	return _X509Helper.Contract.GetSerialNumber(&_X509Helper.CallOpts, der)
+}
+
+// GetSerialNumber is a free data retrieval call binding the contract method 0xb29b51cb.
+//
+// Solidity: function getSerialNumber(bytes der) pure returns(uint256 serialNum)
+func (_X509Helper *X509HelperCallerSession) GetSerialNumber(der []byte) (*big.Int, error) {
+	return _X509Helper.Contract.GetSerialNumber(&_X509Helper.CallOpts, der)
+}
+
+// GetSubjectCommonName is a free data retrieval call binding the contract method 0x35c757bd.
+//
+// Solidity: function getSubjectCommonName(bytes der) pure returns(string subjectCommonName)
+func (_X509Helper *X509HelperCaller) GetSubjectCommonName(opts *bind.CallOpts, der []byte) (string, error) {
+	var out []interface{}
+	err := _X509Helper.contract.Call(opts, &out, "getSubjectCommonName", der)
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// GetSubjectCommonName is a free data retrieval call binding the contract method 0x35c757bd.
+//
+// Solidity: function getSubjectCommonName(bytes der) pure returns(string subjectCommonName)
+func (_X509Helper *X509HelperSession) GetSubjectCommonName(der []byte) (string, error) {
+	return _X509Helper.Contract.GetSubjectCommonName(&_X509Helper.CallOpts, der)
+}
+
+// GetSubjectCommonName is a free data retrieval call binding the contract method 0x35c757bd.
+//
+// Solidity: function getSubjectCommonName(bytes der) pure returns(string subjectCommonName)
+func (_X509Helper *X509HelperCallerSession) GetSubjectCommonName(der []byte) (string, error) {
+	return _X509Helper.Contract.GetSubjectCommonName(&_X509Helper.CallOpts, der)
+}
+
+// GetSubjectPublicKey is a free data retrieval call binding the contract method 0x6d3537a0.
+//
+// Solidity: function getSubjectPublicKey(bytes der) pure returns(bytes pubKey)
+func (_X509Helper *X509HelperCaller) GetSubjectPublicKey(opts *bind.CallOpts, der []byte) ([]byte, error) {
+	var out []interface{}
+	err := _X509Helper.contract.Call(opts, &out, "getSubjectPublicKey", der)
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// GetSubjectPublicKey is a free data retrieval call binding the contract method 0x6d3537a0.
+//
+// Solidity: function getSubjectPublicKey(bytes der) pure returns(bytes pubKey)
+func (_X509Helper *X509HelperSession) GetSubjectPublicKey(der []byte) ([]byte, error) {
+	return _X509Helper.Contract.GetSubjectPublicKey(&_X509Helper.CallOpts, der)
+}
+
+// GetSubjectPublicKey is a free data retrieval call binding the contract method 0x6d3537a0.
+//
+// Solidity: function getSubjectPublicKey(bytes der) pure returns(bytes pubKey)
+func (_X509Helper *X509HelperCallerSession) GetSubjectPublicKey(der []byte) ([]byte, error) {
+	return _X509Helper.Contract.GetSubjectPublicKey(&_X509Helper.CallOpts, der)
+}
+
+// GetTbsAndSig is a free data retrieval call binding the contract method 0xfcf0be24.
+//
+// Solidity: function getTbsAndSig(bytes der) pure returns(bytes tbs, bytes sig)
+func (_X509Helper *X509HelperCaller) GetTbsAndSig(opts *bind.CallOpts, der []byte) (struct {
+	Tbs []byte
+	Sig []byte
+}, error) {
+	var out []interface{}
+	err := _X509Helper.contract.Call(opts, &out, "getTbsAndSig", der)
+
+	outstruct := new(struct {
+		Tbs []byte
+		Sig []byte
+	})
+	if err != nil {
+		return *outstruct, err
+	}
+
+	outstruct.Tbs = *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+	outstruct.Sig = *abi.ConvertType(out[1], new([]byte)).(*[]byte)
+
+	return *outstruct, err
+
+}
+
+// GetTbsAndSig is a free data retrieval call binding the contract method 0xfcf0be24.
+//
+// Solidity: function getTbsAndSig(bytes der) pure returns(bytes tbs, bytes sig)
+func (_X509Helper *X509HelperSession) GetTbsAndSig(der []byte) (struct {
+	Tbs []byte
+	Sig []byte
+}, error) {
+	return _X509Helper.Contract.GetTbsAndSig(&_X509Helper.CallOpts, der)
+}
+
+// GetTbsAndSig is a free data retrieval call binding the contract method 0xfcf0be24.
+//
+// Solidity: function getTbsAndSig(bytes der) pure returns(bytes tbs, bytes sig)
+func (_X509Helper *X509HelperCallerSession) GetTbsAndSig(der []byte) (struct {
+	Tbs []byte
+	Sig []byte
+}, error) {
+	return _X509Helper.Contract.GetTbsAndSig(&_X509Helper.CallOpts, der)
+}
+
+// ParseX509DER is a free data retrieval call binding the contract method 0x3b79a61e.
+//
+// Solidity: function parseX509DER(bytes der) pure returns((uint256,string,uint256,uint256,string,bytes,uint256,bytes,bytes) cert)
+func (_X509Helper *X509HelperCaller) ParseX509DER(opts *bind.CallOpts, der []byte) (X509CertObj, error) {
+	var out []interface{}
+	err := _X509Helper.contract.Call(opts, &out, "parseX509DER", der)
+
+	if err != nil {
+		return *new(X509CertObj), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(X509CertObj)).(*X509CertObj)
+
+	return out0, err
+
+}
+
+// ParseX509DER is a free data retrieval call binding the contract method 0x3b79a61e.
+//
+// Solidity: function parseX509DER(bytes der) pure returns((uint256,string,uint256,uint256,string,bytes,uint256,bytes,bytes) cert)
+func (_X509Helper *X509HelperSession) ParseX509DER(der []byte) (X509CertObj, error) {
+	return _X509Helper.Contract.ParseX509DER(&_X509Helper.CallOpts, der)
+}
+
+// ParseX509DER is a free data retrieval call binding the contract method 0x3b79a61e.
+//
+// Solidity: function parseX509DER(bytes der) pure returns((uint256,string,uint256,uint256,string,bytes,uint256,bytes,bytes) cert)
+func (_X509Helper *X509HelperCallerSession) ParseX509DER(der []byte) (X509CertObj, error) {
+	return _X509Helper.Contract.ParseX509DER(&_X509Helper.CallOpts, der)
+}
+
+// ConsoleMetaData contains all meta data concerning the Console contract.
+var ConsoleMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220c6cfde7df39e35be882769816908ce0c98f5c7d02e4e01b50b7a80b11c82cb1b64736f6c63430008190033",
+}
+
+// ConsoleABI is the input ABI used to generate the binding from.
+// Deprecated: Use ConsoleMetaData.ABI instead.
+var ConsoleABI = ConsoleMetaData.ABI
+
+// ConsoleBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use ConsoleMetaData.Bin instead.
+var ConsoleBin = ConsoleMetaData.Bin
+
+// DeployConsole deploys a new Ethereum contract, binding an instance of Console to it.
+func DeployConsole(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Console, error) {
+	parsed, err := ConsoleMetaData.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(ConsoleBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &Console{ConsoleCaller: ConsoleCaller{contract: contract}, ConsoleTransactor: ConsoleTransactor{contract: contract}, ConsoleFilterer: ConsoleFilterer{contract: contract}}, nil
+}
+
+// Console is an auto generated Go binding around an Ethereum contract.
+type Console struct {
+	ConsoleCaller     // Read-only binding to the contract
+	ConsoleTransactor // Write-only binding to the contract
+	ConsoleFilterer   // Log filterer for contract events
+}
+
+// ConsoleCaller is an auto generated read-only Go binding around an Ethereum contract.
+type ConsoleCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ConsoleTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type ConsoleTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ConsoleFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type ConsoleFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ConsoleSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type ConsoleSession struct {
+	Contract     *Console          // 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
+}
+
+// ConsoleCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type ConsoleCallerSession struct {
+	Contract *ConsoleCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts  // Call options to use throughout this session
+}
+
+// ConsoleTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type ConsoleTransactorSession struct {
+	Contract     *ConsoleTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
+}
+
+// ConsoleRaw is an auto generated low-level Go binding around an Ethereum contract.
+type ConsoleRaw struct {
+	Contract *Console // Generic contract binding to access the raw methods on
+}
+
+// ConsoleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type ConsoleCallerRaw struct {
+	Contract *ConsoleCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// ConsoleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type ConsoleTransactorRaw struct {
+	Contract *ConsoleTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewConsole creates a new instance of Console, bound to a specific deployed contract.
+func NewConsole(address common.Address, backend bind.ContractBackend) (*Console, error) {
+	contract, err := bindConsole(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Console{ConsoleCaller: ConsoleCaller{contract: contract}, ConsoleTransactor: ConsoleTransactor{contract: contract}, ConsoleFilterer: ConsoleFilterer{contract: contract}}, nil
+}
+
+// NewConsoleCaller creates a new read-only instance of Console, bound to a specific deployed contract.
+func NewConsoleCaller(address common.Address, caller bind.ContractCaller) (*ConsoleCaller, error) {
+	contract, err := bindConsole(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ConsoleCaller{contract: contract}, nil
+}
+
+// NewConsoleTransactor creates a new write-only instance of Console, bound to a specific deployed contract.
+func NewConsoleTransactor(address common.Address, transactor bind.ContractTransactor) (*ConsoleTransactor, error) {
+	contract, err := bindConsole(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ConsoleTransactor{contract: contract}, nil
+}
+
+// NewConsoleFilterer creates a new log filterer instance of Console, bound to a specific deployed contract.
+func NewConsoleFilterer(address common.Address, filterer bind.ContractFilterer) (*ConsoleFilterer, error) {
+	contract, err := bindConsole(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &ConsoleFilterer{contract: contract}, nil
+}
+
+// bindConsole binds a generic wrapper to an already deployed contract.
+func bindConsole(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := ConsoleMetaData.GetAbi()
+	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 (_Console *ConsoleRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Console.Contract.ConsoleCaller.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 (_Console *ConsoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Console.Contract.ConsoleTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Console *ConsoleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Console.Contract.ConsoleTransactor.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 (_Console *ConsoleCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Console.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 (_Console *ConsoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Console.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Console *ConsoleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Console.Contract.contract.Transact(opts, method, params...)
+}
+
+// SafeconsoleMetaData contains all meta data concerning the Safeconsole contract.
+var SafeconsoleMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212209a5b0848c3b7e5f5e3f03bbfd3131224ed71bf21b4410092f327b02296fff46c64736f6c63430008190033",
+}
+
+// SafeconsoleABI is the input ABI used to generate the binding from.
+// Deprecated: Use SafeconsoleMetaData.ABI instead.
+var SafeconsoleABI = SafeconsoleMetaData.ABI
+
+// SafeconsoleBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use SafeconsoleMetaData.Bin instead.
+var SafeconsoleBin = SafeconsoleMetaData.Bin
+
+// DeploySafeconsole deploys a new Ethereum contract, binding an instance of Safeconsole to it.
+func DeploySafeconsole(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Safeconsole, error) {
+	parsed, err := SafeconsoleMetaData.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(SafeconsoleBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &Safeconsole{SafeconsoleCaller: SafeconsoleCaller{contract: contract}, SafeconsoleTransactor: SafeconsoleTransactor{contract: contract}, SafeconsoleFilterer: SafeconsoleFilterer{contract: contract}}, nil
+}
+
+// Safeconsole is an auto generated Go binding around an Ethereum contract.
+type Safeconsole struct {
+	SafeconsoleCaller     // Read-only binding to the contract
+	SafeconsoleTransactor // Write-only binding to the contract
+	SafeconsoleFilterer   // Log filterer for contract events
+}
+
+// SafeconsoleCaller is an auto generated read-only Go binding around an Ethereum contract.
+type SafeconsoleCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// SafeconsoleTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type SafeconsoleTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// SafeconsoleFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type SafeconsoleFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// SafeconsoleSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type SafeconsoleSession struct {
+	Contract     *Safeconsole      // 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
+}
+
+// SafeconsoleCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type SafeconsoleCallerSession struct {
+	Contract *SafeconsoleCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts      // Call options to use throughout this session
+}
+
+// SafeconsoleTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type SafeconsoleTransactorSession struct {
+	Contract     *SafeconsoleTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts      // Transaction auth options to use throughout this session
+}
+
+// SafeconsoleRaw is an auto generated low-level Go binding around an Ethereum contract.
+type SafeconsoleRaw struct {
+	Contract *Safeconsole // Generic contract binding to access the raw methods on
+}
+
+// SafeconsoleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type SafeconsoleCallerRaw struct {
+	Contract *SafeconsoleCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// SafeconsoleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type SafeconsoleTransactorRaw struct {
+	Contract *SafeconsoleTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewSafeconsole creates a new instance of Safeconsole, bound to a specific deployed contract.
+func NewSafeconsole(address common.Address, backend bind.ContractBackend) (*Safeconsole, error) {
+	contract, err := bindSafeconsole(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Safeconsole{SafeconsoleCaller: SafeconsoleCaller{contract: contract}, SafeconsoleTransactor: SafeconsoleTransactor{contract: contract}, SafeconsoleFilterer: SafeconsoleFilterer{contract: contract}}, nil
+}
+
+// NewSafeconsoleCaller creates a new read-only instance of Safeconsole, bound to a specific deployed contract.
+func NewSafeconsoleCaller(address common.Address, caller bind.ContractCaller) (*SafeconsoleCaller, error) {
+	contract, err := bindSafeconsole(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &SafeconsoleCaller{contract: contract}, nil
+}
+
+// NewSafeconsoleTransactor creates a new write-only instance of Safeconsole, bound to a specific deployed contract.
+func NewSafeconsoleTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeconsoleTransactor, error) {
+	contract, err := bindSafeconsole(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &SafeconsoleTransactor{contract: contract}, nil
+}
+
+// NewSafeconsoleFilterer creates a new log filterer instance of Safeconsole, bound to a specific deployed contract.
+func NewSafeconsoleFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeconsoleFilterer, error) {
+	contract, err := bindSafeconsole(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &SafeconsoleFilterer{contract: contract}, nil
+}
+
+// bindSafeconsole binds a generic wrapper to an already deployed contract.
+func bindSafeconsole(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := SafeconsoleMetaData.GetAbi()
+	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 (_Safeconsole *SafeconsoleRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Safeconsole.Contract.SafeconsoleCaller.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 (_Safeconsole *SafeconsoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Safeconsole.Contract.SafeconsoleTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Safeconsole *SafeconsoleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Safeconsole.Contract.SafeconsoleTransactor.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 (_Safeconsole *SafeconsoleCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Safeconsole.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 (_Safeconsole *SafeconsoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Safeconsole.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Safeconsole *SafeconsoleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Safeconsole.Contract.contract.Transact(opts, method, params...)
+}
+
+// StdErrorMetaData contains all meta data concerning the StdError contract.
+var StdErrorMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"name\":\"arithmeticError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"assertionError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"divisionError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"encodeStorageError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"enumConversionError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"indexOOBError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"memOverflowError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"popError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zeroVarError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+	Bin: "0x608080604052346019576102ef908161001e823930815050f35b5f80fdfe60806040908082526004361015610014575f80fd5b5f3560e01c90816305ee8612146102325750806310332977146101fe5780631de45560146101ca5780638995290f14610196578063986c5f6814610162578063b22dc54d1461012e578063b67689da146100fa578063d160e4de146100c65763fa784a4414610081575f80fd5b5f3660031901126100c257806100be915190634e487b7160e01b602083015260126024830152602482526100b482610260565b519182918261028f565b0390f35b5f80fd5b505f3660031901126100c257806100be915190634e487b7160e01b602083015260226024830152602482526100b482610260565b505f3660031901126100c257806100be915190634e487b7160e01b602083015260516024830152602482526100b482610260565b505f3660031901126100c257806100be915190634e487b7160e01b602083015260316024830152602482526100b482610260565b505f3660031901126100c257806100be915190634e487b7160e01b602083015260416024830152602482526100b482610260565b505f3660031901126100c257806100be915190634e487b7160e01b602083015260116024830152602482526100b482610260565b505f3660031901126100c257806100be915190634e487b7160e01b602083015260216024830152602482526100b482610260565b505f3660031901126100c257806100be915190634e487b7160e01b602083015260016024830152602482526100b482610260565b90505f3660031901126100c2576100be91634e487b7160e01b602083015260326024830152602482526100b4825b606081019081106001600160401b0382111761027b57604052565b634e487b7160e01b5f52604160045260245ffd5b602060409281835280519182918282860152018484015e5f828201840152601f01601f191601019056fea2646970667358221220626b5cf4c98155d4179878d59bfdb6e7790628ce25c4f3e15e5690550baa68ac64736f6c63430008190033",
+}
+
+// StdErrorABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdErrorMetaData.ABI instead.
+var StdErrorABI = StdErrorMetaData.ABI
+
+// StdErrorBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use StdErrorMetaData.Bin instead.
+var StdErrorBin = StdErrorMetaData.Bin
+
+// DeployStdError deploys a new Ethereum contract, binding an instance of StdError to it.
+func DeployStdError(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdError, error) {
+	parsed, err := StdErrorMetaData.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(StdErrorBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &StdError{StdErrorCaller: StdErrorCaller{contract: contract}, StdErrorTransactor: StdErrorTransactor{contract: contract}, StdErrorFilterer: StdErrorFilterer{contract: contract}}, nil
+}
+
+// StdError is an auto generated Go binding around an Ethereum contract.
+type StdError struct {
+	StdErrorCaller     // Read-only binding to the contract
+	StdErrorTransactor // Write-only binding to the contract
+	StdErrorFilterer   // Log filterer for contract events
+}
+
+// StdErrorCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdErrorCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdErrorTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdErrorTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdErrorFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdErrorFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdErrorSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdErrorSession struct {
+	Contract     *StdError         // 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
+}
+
+// StdErrorCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdErrorCallerSession struct {
+	Contract *StdErrorCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts   // Call options to use throughout this session
+}
+
+// StdErrorTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdErrorTransactorSession struct {
+	Contract     *StdErrorTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
+}
+
+// StdErrorRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdErrorRaw struct {
+	Contract *StdError // Generic contract binding to access the raw methods on
+}
+
+// StdErrorCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdErrorCallerRaw struct {
+	Contract *StdErrorCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdErrorTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdErrorTransactorRaw struct {
+	Contract *StdErrorTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdError creates a new instance of StdError, bound to a specific deployed contract.
+func NewStdError(address common.Address, backend bind.ContractBackend) (*StdError, error) {
+	contract, err := bindStdError(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdError{StdErrorCaller: StdErrorCaller{contract: contract}, StdErrorTransactor: StdErrorTransactor{contract: contract}, StdErrorFilterer: StdErrorFilterer{contract: contract}}, nil
+}
+
+// NewStdErrorCaller creates a new read-only instance of StdError, bound to a specific deployed contract.
+func NewStdErrorCaller(address common.Address, caller bind.ContractCaller) (*StdErrorCaller, error) {
+	contract, err := bindStdError(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdErrorCaller{contract: contract}, nil
+}
+
+// NewStdErrorTransactor creates a new write-only instance of StdError, bound to a specific deployed contract.
+func NewStdErrorTransactor(address common.Address, transactor bind.ContractTransactor) (*StdErrorTransactor, error) {
+	contract, err := bindStdError(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdErrorTransactor{contract: contract}, nil
+}
+
+// NewStdErrorFilterer creates a new log filterer instance of StdError, bound to a specific deployed contract.
+func NewStdErrorFilterer(address common.Address, filterer bind.ContractFilterer) (*StdErrorFilterer, error) {
+	contract, err := bindStdError(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdErrorFilterer{contract: contract}, nil
+}
+
+// bindStdError binds a generic wrapper to an already deployed contract.
+func bindStdError(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdErrorMetaData.GetAbi()
+	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 (_StdError *StdErrorRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdError.Contract.StdErrorCaller.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 (_StdError *StdErrorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdError.Contract.StdErrorTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdError *StdErrorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdError.Contract.StdErrorTransactor.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 (_StdError *StdErrorCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdError.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 (_StdError *StdErrorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdError.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdError *StdErrorTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdError.Contract.contract.Transact(opts, method, params...)
+}
+
+// ArithmeticError is a free data retrieval call binding the contract method 0x8995290f.
+//
+// Solidity: function arithmeticError() view returns(bytes)
+func (_StdError *StdErrorCaller) ArithmeticError(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _StdError.contract.Call(opts, &out, "arithmeticError")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ArithmeticError is a free data retrieval call binding the contract method 0x8995290f.
+//
+// Solidity: function arithmeticError() view returns(bytes)
+func (_StdError *StdErrorSession) ArithmeticError() ([]byte, error) {
+	return _StdError.Contract.ArithmeticError(&_StdError.CallOpts)
+}
+
+// ArithmeticError is a free data retrieval call binding the contract method 0x8995290f.
+//
+// Solidity: function arithmeticError() view returns(bytes)
+func (_StdError *StdErrorCallerSession) ArithmeticError() ([]byte, error) {
+	return _StdError.Contract.ArithmeticError(&_StdError.CallOpts)
+}
+
+// AssertionError is a free data retrieval call binding the contract method 0x10332977.
+//
+// Solidity: function assertionError() view returns(bytes)
+func (_StdError *StdErrorCaller) AssertionError(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _StdError.contract.Call(opts, &out, "assertionError")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// AssertionError is a free data retrieval call binding the contract method 0x10332977.
+//
+// Solidity: function assertionError() view returns(bytes)
+func (_StdError *StdErrorSession) AssertionError() ([]byte, error) {
+	return _StdError.Contract.AssertionError(&_StdError.CallOpts)
+}
+
+// AssertionError is a free data retrieval call binding the contract method 0x10332977.
+//
+// Solidity: function assertionError() view returns(bytes)
+func (_StdError *StdErrorCallerSession) AssertionError() ([]byte, error) {
+	return _StdError.Contract.AssertionError(&_StdError.CallOpts)
+}
+
+// DivisionError is a free data retrieval call binding the contract method 0xfa784a44.
+//
+// Solidity: function divisionError() view returns(bytes)
+func (_StdError *StdErrorCaller) DivisionError(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _StdError.contract.Call(opts, &out, "divisionError")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// DivisionError is a free data retrieval call binding the contract method 0xfa784a44.
+//
+// Solidity: function divisionError() view returns(bytes)
+func (_StdError *StdErrorSession) DivisionError() ([]byte, error) {
+	return _StdError.Contract.DivisionError(&_StdError.CallOpts)
+}
+
+// DivisionError is a free data retrieval call binding the contract method 0xfa784a44.
+//
+// Solidity: function divisionError() view returns(bytes)
+func (_StdError *StdErrorCallerSession) DivisionError() ([]byte, error) {
+	return _StdError.Contract.DivisionError(&_StdError.CallOpts)
+}
+
+// EncodeStorageError is a free data retrieval call binding the contract method 0xd160e4de.
+//
+// Solidity: function encodeStorageError() view returns(bytes)
+func (_StdError *StdErrorCaller) EncodeStorageError(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _StdError.contract.Call(opts, &out, "encodeStorageError")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// EncodeStorageError is a free data retrieval call binding the contract method 0xd160e4de.
+//
+// Solidity: function encodeStorageError() view returns(bytes)
+func (_StdError *StdErrorSession) EncodeStorageError() ([]byte, error) {
+	return _StdError.Contract.EncodeStorageError(&_StdError.CallOpts)
+}
+
+// EncodeStorageError is a free data retrieval call binding the contract method 0xd160e4de.
+//
+// Solidity: function encodeStorageError() view returns(bytes)
+func (_StdError *StdErrorCallerSession) EncodeStorageError() ([]byte, error) {
+	return _StdError.Contract.EncodeStorageError(&_StdError.CallOpts)
+}
+
+// EnumConversionError is a free data retrieval call binding the contract method 0x1de45560.
+//
+// Solidity: function enumConversionError() view returns(bytes)
+func (_StdError *StdErrorCaller) EnumConversionError(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _StdError.contract.Call(opts, &out, "enumConversionError")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// EnumConversionError is a free data retrieval call binding the contract method 0x1de45560.
+//
+// Solidity: function enumConversionError() view returns(bytes)
+func (_StdError *StdErrorSession) EnumConversionError() ([]byte, error) {
+	return _StdError.Contract.EnumConversionError(&_StdError.CallOpts)
+}
+
+// EnumConversionError is a free data retrieval call binding the contract method 0x1de45560.
+//
+// Solidity: function enumConversionError() view returns(bytes)
+func (_StdError *StdErrorCallerSession) EnumConversionError() ([]byte, error) {
+	return _StdError.Contract.EnumConversionError(&_StdError.CallOpts)
+}
+
+// IndexOOBError is a free data retrieval call binding the contract method 0x05ee8612.
+//
+// Solidity: function indexOOBError() view returns(bytes)
+func (_StdError *StdErrorCaller) IndexOOBError(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _StdError.contract.Call(opts, &out, "indexOOBError")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// IndexOOBError is a free data retrieval call binding the contract method 0x05ee8612.
+//
+// Solidity: function indexOOBError() view returns(bytes)
+func (_StdError *StdErrorSession) IndexOOBError() ([]byte, error) {
+	return _StdError.Contract.IndexOOBError(&_StdError.CallOpts)
+}
+
+// IndexOOBError is a free data retrieval call binding the contract method 0x05ee8612.
+//
+// Solidity: function indexOOBError() view returns(bytes)
+func (_StdError *StdErrorCallerSession) IndexOOBError() ([]byte, error) {
+	return _StdError.Contract.IndexOOBError(&_StdError.CallOpts)
+}
+
+// MemOverflowError is a free data retrieval call binding the contract method 0x986c5f68.
+//
+// Solidity: function memOverflowError() view returns(bytes)
+func (_StdError *StdErrorCaller) MemOverflowError(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _StdError.contract.Call(opts, &out, "memOverflowError")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// MemOverflowError is a free data retrieval call binding the contract method 0x986c5f68.
+//
+// Solidity: function memOverflowError() view returns(bytes)
+func (_StdError *StdErrorSession) MemOverflowError() ([]byte, error) {
+	return _StdError.Contract.MemOverflowError(&_StdError.CallOpts)
+}
+
+// MemOverflowError is a free data retrieval call binding the contract method 0x986c5f68.
+//
+// Solidity: function memOverflowError() view returns(bytes)
+func (_StdError *StdErrorCallerSession) MemOverflowError() ([]byte, error) {
+	return _StdError.Contract.MemOverflowError(&_StdError.CallOpts)
+}
+
+// PopError is a free data retrieval call binding the contract method 0xb22dc54d.
+//
+// Solidity: function popError() view returns(bytes)
+func (_StdError *StdErrorCaller) PopError(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _StdError.contract.Call(opts, &out, "popError")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// PopError is a free data retrieval call binding the contract method 0xb22dc54d.
+//
+// Solidity: function popError() view returns(bytes)
+func (_StdError *StdErrorSession) PopError() ([]byte, error) {
+	return _StdError.Contract.PopError(&_StdError.CallOpts)
+}
+
+// PopError is a free data retrieval call binding the contract method 0xb22dc54d.
+//
+// Solidity: function popError() view returns(bytes)
+func (_StdError *StdErrorCallerSession) PopError() ([]byte, error) {
+	return _StdError.Contract.PopError(&_StdError.CallOpts)
+}
+
+// ZeroVarError is a free data retrieval call binding the contract method 0xb67689da.
+//
+// Solidity: function zeroVarError() view returns(bytes)
+func (_StdError *StdErrorCaller) ZeroVarError(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _StdError.contract.Call(opts, &out, "zeroVarError")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// ZeroVarError is a free data retrieval call binding the contract method 0xb67689da.
+//
+// Solidity: function zeroVarError() view returns(bytes)
+func (_StdError *StdErrorSession) ZeroVarError() ([]byte, error) {
+	return _StdError.Contract.ZeroVarError(&_StdError.CallOpts)
+}
+
+// ZeroVarError is a free data retrieval call binding the contract method 0xb67689da.
+//
+// Solidity: function zeroVarError() view returns(bytes)
+func (_StdError *StdErrorCallerSession) ZeroVarError() ([]byte, error) {
+	return _StdError.Contract.ZeroVarError(&_StdError.CallOpts)
+}
+
+// StdJsonMetaData contains all meta data concerning the StdJson contract.
+var StdJsonMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212202a5fdc7b0dbd6db29c777f42317e8c4b67ae1b83d59186c481e5d13c6ee56fce64736f6c63430008190033",
+}
+
+// StdJsonABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdJsonMetaData.ABI instead.
+var StdJsonABI = StdJsonMetaData.ABI
+
+// StdJsonBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use StdJsonMetaData.Bin instead.
+var StdJsonBin = StdJsonMetaData.Bin
+
+// DeployStdJson deploys a new Ethereum contract, binding an instance of StdJson to it.
+func DeployStdJson(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdJson, error) {
+	parsed, err := StdJsonMetaData.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(StdJsonBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &StdJson{StdJsonCaller: StdJsonCaller{contract: contract}, StdJsonTransactor: StdJsonTransactor{contract: contract}, StdJsonFilterer: StdJsonFilterer{contract: contract}}, nil
+}
+
+// StdJson is an auto generated Go binding around an Ethereum contract.
+type StdJson struct {
+	StdJsonCaller     // Read-only binding to the contract
+	StdJsonTransactor // Write-only binding to the contract
+	StdJsonFilterer   // Log filterer for contract events
+}
+
+// StdJsonCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdJsonCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdJsonTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdJsonTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdJsonFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdJsonFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdJsonSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdJsonSession struct {
+	Contract     *StdJson          // 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
+}
+
+// StdJsonCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdJsonCallerSession struct {
+	Contract *StdJsonCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts  // Call options to use throughout this session
+}
+
+// StdJsonTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdJsonTransactorSession struct {
+	Contract     *StdJsonTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
+}
+
+// StdJsonRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdJsonRaw struct {
+	Contract *StdJson // Generic contract binding to access the raw methods on
+}
+
+// StdJsonCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdJsonCallerRaw struct {
+	Contract *StdJsonCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdJsonTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdJsonTransactorRaw struct {
+	Contract *StdJsonTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdJson creates a new instance of StdJson, bound to a specific deployed contract.
+func NewStdJson(address common.Address, backend bind.ContractBackend) (*StdJson, error) {
+	contract, err := bindStdJson(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdJson{StdJsonCaller: StdJsonCaller{contract: contract}, StdJsonTransactor: StdJsonTransactor{contract: contract}, StdJsonFilterer: StdJsonFilterer{contract: contract}}, nil
+}
+
+// NewStdJsonCaller creates a new read-only instance of StdJson, bound to a specific deployed contract.
+func NewStdJsonCaller(address common.Address, caller bind.ContractCaller) (*StdJsonCaller, error) {
+	contract, err := bindStdJson(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdJsonCaller{contract: contract}, nil
+}
+
+// NewStdJsonTransactor creates a new write-only instance of StdJson, bound to a specific deployed contract.
+func NewStdJsonTransactor(address common.Address, transactor bind.ContractTransactor) (*StdJsonTransactor, error) {
+	contract, err := bindStdJson(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdJsonTransactor{contract: contract}, nil
+}
+
+// NewStdJsonFilterer creates a new log filterer instance of StdJson, bound to a specific deployed contract.
+func NewStdJsonFilterer(address common.Address, filterer bind.ContractFilterer) (*StdJsonFilterer, error) {
+	contract, err := bindStdJson(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdJsonFilterer{contract: contract}, nil
+}
+
+// bindStdJson binds a generic wrapper to an already deployed contract.
+func bindStdJson(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdJsonMetaData.GetAbi()
+	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 (_StdJson *StdJsonRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdJson.Contract.StdJsonCaller.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 (_StdJson *StdJsonRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdJson.Contract.StdJsonTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdJson *StdJsonRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdJson.Contract.StdJsonTransactor.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 (_StdJson *StdJsonCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdJson.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 (_StdJson *StdJsonTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdJson.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdJson *StdJsonTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdJson.Contract.contract.Transact(opts, method, params...)
+}
+
+// StdMathMetaData contains all meta data concerning the StdMath contract.
+var StdMathMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea264697066735822122051bad800356226d155ffbaf6ebb463ca56ca45405623bfd1f5eac9642d71971764736f6c63430008190033",
+}
+
+// StdMathABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdMathMetaData.ABI instead.
+var StdMathABI = StdMathMetaData.ABI
+
+// StdMathBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use StdMathMetaData.Bin instead.
+var StdMathBin = StdMathMetaData.Bin
+
+// DeployStdMath deploys a new Ethereum contract, binding an instance of StdMath to it.
+func DeployStdMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdMath, error) {
+	parsed, err := StdMathMetaData.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(StdMathBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &StdMath{StdMathCaller: StdMathCaller{contract: contract}, StdMathTransactor: StdMathTransactor{contract: contract}, StdMathFilterer: StdMathFilterer{contract: contract}}, nil
+}
+
+// StdMath is an auto generated Go binding around an Ethereum contract.
+type StdMath struct {
+	StdMathCaller     // Read-only binding to the contract
+	StdMathTransactor // Write-only binding to the contract
+	StdMathFilterer   // Log filterer for contract events
+}
+
+// StdMathCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdMathCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdMathTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdMathTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdMathFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdMathSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdMathSession struct {
+	Contract     *StdMath          // 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
+}
+
+// StdMathCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdMathCallerSession struct {
+	Contract *StdMathCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts  // Call options to use throughout this session
+}
+
+// StdMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdMathTransactorSession struct {
+	Contract     *StdMathTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
+}
+
+// StdMathRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdMathRaw struct {
+	Contract *StdMath // Generic contract binding to access the raw methods on
+}
+
+// StdMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdMathCallerRaw struct {
+	Contract *StdMathCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdMathTransactorRaw struct {
+	Contract *StdMathTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdMath creates a new instance of StdMath, bound to a specific deployed contract.
+func NewStdMath(address common.Address, backend bind.ContractBackend) (*StdMath, error) {
+	contract, err := bindStdMath(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdMath{StdMathCaller: StdMathCaller{contract: contract}, StdMathTransactor: StdMathTransactor{contract: contract}, StdMathFilterer: StdMathFilterer{contract: contract}}, nil
+}
+
+// NewStdMathCaller creates a new read-only instance of StdMath, bound to a specific deployed contract.
+func NewStdMathCaller(address common.Address, caller bind.ContractCaller) (*StdMathCaller, error) {
+	contract, err := bindStdMath(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdMathCaller{contract: contract}, nil
+}
+
+// NewStdMathTransactor creates a new write-only instance of StdMath, bound to a specific deployed contract.
+func NewStdMathTransactor(address common.Address, transactor bind.ContractTransactor) (*StdMathTransactor, error) {
+	contract, err := bindStdMath(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdMathTransactor{contract: contract}, nil
+}
+
+// NewStdMathFilterer creates a new log filterer instance of StdMath, bound to a specific deployed contract.
+func NewStdMathFilterer(address common.Address, filterer bind.ContractFilterer) (*StdMathFilterer, error) {
+	contract, err := bindStdMath(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdMathFilterer{contract: contract}, nil
+}
+
+// bindStdMath binds a generic wrapper to an already deployed contract.
+func bindStdMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdMathMetaData.GetAbi()
+	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 (_StdMath *StdMathRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdMath.Contract.StdMathCaller.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 (_StdMath *StdMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdMath.Contract.StdMathTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdMath *StdMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdMath.Contract.StdMathTransactor.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 (_StdMath *StdMathCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdMath.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 (_StdMath *StdMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdMath.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdMath *StdMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdMath.Contract.contract.Transact(opts, method, params...)
+}
+
+// StdStorageMetaData contains all meta data concerning the StdStorage contract.
+var StdStorageMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220ae0c3ef6c20f3ccc792c677bb735bbec4492c2de342b687a28f828384066d93764736f6c63430008190033",
+}
+
+// StdStorageABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdStorageMetaData.ABI instead.
+var StdStorageABI = StdStorageMetaData.ABI
+
+// StdStorageBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use StdStorageMetaData.Bin instead.
+var StdStorageBin = StdStorageMetaData.Bin
+
+// DeployStdStorage deploys a new Ethereum contract, binding an instance of StdStorage to it.
+func DeployStdStorage(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdStorage, error) {
+	parsed, err := StdStorageMetaData.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(StdStorageBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &StdStorage{StdStorageCaller: StdStorageCaller{contract: contract}, StdStorageTransactor: StdStorageTransactor{contract: contract}, StdStorageFilterer: StdStorageFilterer{contract: contract}}, nil
+}
+
+// StdStorage is an auto generated Go binding around an Ethereum contract.
+type StdStorage struct {
+	StdStorageCaller     // Read-only binding to the contract
+	StdStorageTransactor // Write-only binding to the contract
+	StdStorageFilterer   // Log filterer for contract events
+}
+
+// StdStorageCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdStorageCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdStorageTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdStorageTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdStorageFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdStorageFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdStorageSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdStorageSession struct {
+	Contract     *StdStorage       // 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
+}
+
+// StdStorageCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdStorageCallerSession struct {
+	Contract *StdStorageCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts     // Call options to use throughout this session
+}
+
+// StdStorageTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdStorageTransactorSession struct {
+	Contract     *StdStorageTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
+}
+
+// StdStorageRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdStorageRaw struct {
+	Contract *StdStorage // Generic contract binding to access the raw methods on
+}
+
+// StdStorageCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdStorageCallerRaw struct {
+	Contract *StdStorageCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdStorageTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdStorageTransactorRaw struct {
+	Contract *StdStorageTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdStorage creates a new instance of StdStorage, bound to a specific deployed contract.
+func NewStdStorage(address common.Address, backend bind.ContractBackend) (*StdStorage, error) {
+	contract, err := bindStdStorage(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdStorage{StdStorageCaller: StdStorageCaller{contract: contract}, StdStorageTransactor: StdStorageTransactor{contract: contract}, StdStorageFilterer: StdStorageFilterer{contract: contract}}, nil
+}
+
+// NewStdStorageCaller creates a new read-only instance of StdStorage, bound to a specific deployed contract.
+func NewStdStorageCaller(address common.Address, caller bind.ContractCaller) (*StdStorageCaller, error) {
+	contract, err := bindStdStorage(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdStorageCaller{contract: contract}, nil
+}
+
+// NewStdStorageTransactor creates a new write-only instance of StdStorage, bound to a specific deployed contract.
+func NewStdStorageTransactor(address common.Address, transactor bind.ContractTransactor) (*StdStorageTransactor, error) {
+	contract, err := bindStdStorage(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdStorageTransactor{contract: contract}, nil
+}
+
+// NewStdStorageFilterer creates a new log filterer instance of StdStorage, bound to a specific deployed contract.
+func NewStdStorageFilterer(address common.Address, filterer bind.ContractFilterer) (*StdStorageFilterer, error) {
+	contract, err := bindStdStorage(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdStorageFilterer{contract: contract}, nil
+}
+
+// bindStdStorage binds a generic wrapper to an already deployed contract.
+func bindStdStorage(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdStorageMetaData.GetAbi()
+	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 (_StdStorage *StdStorageRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdStorage.Contract.StdStorageCaller.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 (_StdStorage *StdStorageRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdStorage.Contract.StdStorageTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdStorage *StdStorageRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdStorage.Contract.StdStorageTransactor.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 (_StdStorage *StdStorageCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdStorage.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 (_StdStorage *StdStorageTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdStorage.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdStorage *StdStorageTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdStorage.Contract.contract.Transact(opts, method, params...)
+}
+
+// StdStorageSafeMetaData contains all meta data concerning the StdStorageSafe contract.
+var StdStorageSafeMetaData = &bind.MetaData{
+	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"who\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes4\",\"name\":\"fsig\",\"type\":\"bytes4\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"keysHash\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slot\",\"type\":\"uint256\"}],\"name\":\"SlotFound\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"who\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slot\",\"type\":\"uint256\"}],\"name\":\"WARNING_UninitedSlot\",\"type\":\"event\"}]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212209d92cfe177992798660a425f2f46c2313c82bab41f03245497fa2d453ffae4e764736f6c63430008190033",
+}
+
+// StdStorageSafeABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdStorageSafeMetaData.ABI instead.
+var StdStorageSafeABI = StdStorageSafeMetaData.ABI
+
+// StdStorageSafeBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use StdStorageSafeMetaData.Bin instead.
+var StdStorageSafeBin = StdStorageSafeMetaData.Bin
+
+// DeployStdStorageSafe deploys a new Ethereum contract, binding an instance of StdStorageSafe to it.
+func DeployStdStorageSafe(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdStorageSafe, error) {
+	parsed, err := StdStorageSafeMetaData.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(StdStorageSafeBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &StdStorageSafe{StdStorageSafeCaller: StdStorageSafeCaller{contract: contract}, StdStorageSafeTransactor: StdStorageSafeTransactor{contract: contract}, StdStorageSafeFilterer: StdStorageSafeFilterer{contract: contract}}, nil
+}
+
+// StdStorageSafe is an auto generated Go binding around an Ethereum contract.
+type StdStorageSafe struct {
+	StdStorageSafeCaller     // Read-only binding to the contract
+	StdStorageSafeTransactor // Write-only binding to the contract
+	StdStorageSafeFilterer   // Log filterer for contract events
+}
+
+// StdStorageSafeCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdStorageSafeCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdStorageSafeTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdStorageSafeTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdStorageSafeFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdStorageSafeFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdStorageSafeSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdStorageSafeSession struct {
+	Contract     *StdStorageSafe   // 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
+}
+
+// StdStorageSafeCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdStorageSafeCallerSession struct {
+	Contract *StdStorageSafeCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts         // Call options to use throughout this session
+}
+
+// StdStorageSafeTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdStorageSafeTransactorSession struct {
+	Contract     *StdStorageSafeTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
+}
+
+// StdStorageSafeRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdStorageSafeRaw struct {
+	Contract *StdStorageSafe // Generic contract binding to access the raw methods on
+}
+
+// StdStorageSafeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdStorageSafeCallerRaw struct {
+	Contract *StdStorageSafeCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdStorageSafeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdStorageSafeTransactorRaw struct {
+	Contract *StdStorageSafeTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdStorageSafe creates a new instance of StdStorageSafe, bound to a specific deployed contract.
+func NewStdStorageSafe(address common.Address, backend bind.ContractBackend) (*StdStorageSafe, error) {
+	contract, err := bindStdStorageSafe(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdStorageSafe{StdStorageSafeCaller: StdStorageSafeCaller{contract: contract}, StdStorageSafeTransactor: StdStorageSafeTransactor{contract: contract}, StdStorageSafeFilterer: StdStorageSafeFilterer{contract: contract}}, nil
+}
+
+// NewStdStorageSafeCaller creates a new read-only instance of StdStorageSafe, bound to a specific deployed contract.
+func NewStdStorageSafeCaller(address common.Address, caller bind.ContractCaller) (*StdStorageSafeCaller, error) {
+	contract, err := bindStdStorageSafe(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdStorageSafeCaller{contract: contract}, nil
+}
+
+// NewStdStorageSafeTransactor creates a new write-only instance of StdStorageSafe, bound to a specific deployed contract.
+func NewStdStorageSafeTransactor(address common.Address, transactor bind.ContractTransactor) (*StdStorageSafeTransactor, error) {
+	contract, err := bindStdStorageSafe(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdStorageSafeTransactor{contract: contract}, nil
+}
+
+// NewStdStorageSafeFilterer creates a new log filterer instance of StdStorageSafe, bound to a specific deployed contract.
+func NewStdStorageSafeFilterer(address common.Address, filterer bind.ContractFilterer) (*StdStorageSafeFilterer, error) {
+	contract, err := bindStdStorageSafe(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdStorageSafeFilterer{contract: contract}, nil
+}
+
+// bindStdStorageSafe binds a generic wrapper to an already deployed contract.
+func bindStdStorageSafe(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdStorageSafeMetaData.GetAbi()
+	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 (_StdStorageSafe *StdStorageSafeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdStorageSafe.Contract.StdStorageSafeCaller.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 (_StdStorageSafe *StdStorageSafeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdStorageSafe.Contract.StdStorageSafeTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdStorageSafe *StdStorageSafeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdStorageSafe.Contract.StdStorageSafeTransactor.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 (_StdStorageSafe *StdStorageSafeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdStorageSafe.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 (_StdStorageSafe *StdStorageSafeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdStorageSafe.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdStorageSafe *StdStorageSafeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdStorageSafe.Contract.contract.Transact(opts, method, params...)
+}
+
+// StdStorageSafeSlotFoundIterator is returned from FilterSlotFound and is used to iterate over the raw logs and unpacked data for SlotFound events raised by the StdStorageSafe contract.
+type StdStorageSafeSlotFoundIterator struct {
+	Event *StdStorageSafeSlotFound // 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 *StdStorageSafeSlotFoundIterator) 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(StdStorageSafeSlotFound)
+			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(StdStorageSafeSlotFound)
+		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 *StdStorageSafeSlotFoundIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdStorageSafeSlotFoundIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdStorageSafeSlotFound represents a SlotFound event raised by the StdStorageSafe contract.
+type StdStorageSafeSlotFound struct {
+	Who      common.Address
+	Fsig     [4]byte
+	KeysHash [32]byte
+	Slot     *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterSlotFound is a free log retrieval operation binding the contract event 0x9c9555b1e3102e3cf48f427d79cb678f5d9bd1ed0ad574389461e255f95170ed.
+//
+// Solidity: event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot)
+func (_StdStorageSafe *StdStorageSafeFilterer) FilterSlotFound(opts *bind.FilterOpts) (*StdStorageSafeSlotFoundIterator, error) {
+
+	logs, sub, err := _StdStorageSafe.contract.FilterLogs(opts, "SlotFound")
+	if err != nil {
+		return nil, err
+	}
+	return &StdStorageSafeSlotFoundIterator{contract: _StdStorageSafe.contract, event: "SlotFound", logs: logs, sub: sub}, nil
+}
+
+// WatchSlotFound is a free log subscription operation binding the contract event 0x9c9555b1e3102e3cf48f427d79cb678f5d9bd1ed0ad574389461e255f95170ed.
+//
+// Solidity: event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot)
+func (_StdStorageSafe *StdStorageSafeFilterer) WatchSlotFound(opts *bind.WatchOpts, sink chan<- *StdStorageSafeSlotFound) (event.Subscription, error) {
+
+	logs, sub, err := _StdStorageSafe.contract.WatchLogs(opts, "SlotFound")
+	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(StdStorageSafeSlotFound)
+				if err := _StdStorageSafe.contract.UnpackLog(event, "SlotFound", 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
+}
+
+// ParseSlotFound is a log parse operation binding the contract event 0x9c9555b1e3102e3cf48f427d79cb678f5d9bd1ed0ad574389461e255f95170ed.
+//
+// Solidity: event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot)
+func (_StdStorageSafe *StdStorageSafeFilterer) ParseSlotFound(log types.Log) (*StdStorageSafeSlotFound, error) {
+	event := new(StdStorageSafeSlotFound)
+	if err := _StdStorageSafe.contract.UnpackLog(event, "SlotFound", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdStorageSafeWARNINGUninitedSlotIterator is returned from FilterWARNINGUninitedSlot and is used to iterate over the raw logs and unpacked data for WARNINGUninitedSlot events raised by the StdStorageSafe contract.
+type StdStorageSafeWARNINGUninitedSlotIterator struct {
+	Event *StdStorageSafeWARNINGUninitedSlot // 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 *StdStorageSafeWARNINGUninitedSlotIterator) 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(StdStorageSafeWARNINGUninitedSlot)
+			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(StdStorageSafeWARNINGUninitedSlot)
+		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 *StdStorageSafeWARNINGUninitedSlotIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *StdStorageSafeWARNINGUninitedSlotIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// StdStorageSafeWARNINGUninitedSlot represents a WARNINGUninitedSlot event raised by the StdStorageSafe contract.
+type StdStorageSafeWARNINGUninitedSlot struct {
+	Who  common.Address
+	Slot *big.Int
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterWARNINGUninitedSlot is a free log retrieval operation binding the contract event 0x080fc4a96620c4462e705b23f346413fe3796bb63c6f8d8591baec0e231577a5.
+//
+// Solidity: event WARNING_UninitedSlot(address who, uint256 slot)
+func (_StdStorageSafe *StdStorageSafeFilterer) FilterWARNINGUninitedSlot(opts *bind.FilterOpts) (*StdStorageSafeWARNINGUninitedSlotIterator, error) {
+
+	logs, sub, err := _StdStorageSafe.contract.FilterLogs(opts, "WARNING_UninitedSlot")
+	if err != nil {
+		return nil, err
+	}
+	return &StdStorageSafeWARNINGUninitedSlotIterator{contract: _StdStorageSafe.contract, event: "WARNING_UninitedSlot", logs: logs, sub: sub}, nil
+}
+
+// WatchWARNINGUninitedSlot is a free log subscription operation binding the contract event 0x080fc4a96620c4462e705b23f346413fe3796bb63c6f8d8591baec0e231577a5.
+//
+// Solidity: event WARNING_UninitedSlot(address who, uint256 slot)
+func (_StdStorageSafe *StdStorageSafeFilterer) WatchWARNINGUninitedSlot(opts *bind.WatchOpts, sink chan<- *StdStorageSafeWARNINGUninitedSlot) (event.Subscription, error) {
+
+	logs, sub, err := _StdStorageSafe.contract.WatchLogs(opts, "WARNING_UninitedSlot")
+	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(StdStorageSafeWARNINGUninitedSlot)
+				if err := _StdStorageSafe.contract.UnpackLog(event, "WARNING_UninitedSlot", 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
+}
+
+// ParseWARNINGUninitedSlot is a log parse operation binding the contract event 0x080fc4a96620c4462e705b23f346413fe3796bb63c6f8d8591baec0e231577a5.
+//
+// Solidity: event WARNING_UninitedSlot(address who, uint256 slot)
+func (_StdStorageSafe *StdStorageSafeFilterer) ParseWARNINGUninitedSlot(log types.Log) (*StdStorageSafeWARNINGUninitedSlot, error) {
+	event := new(StdStorageSafeWARNINGUninitedSlot)
+	if err := _StdStorageSafe.contract.UnpackLog(event, "WARNING_UninitedSlot", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// StdTomlMetaData contains all meta data concerning the StdToml contract.
+var StdTomlMetaData = &bind.MetaData{
+	ABI: "[]",
+	Bin: "0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212205a22da4dfc9c4755025c6a68e4cb4c10b70b1777d731170c29747821a820f8f964736f6c63430008190033",
+}
+
+// StdTomlABI is the input ABI used to generate the binding from.
+// Deprecated: Use StdTomlMetaData.ABI instead.
+var StdTomlABI = StdTomlMetaData.ABI
+
+// StdTomlBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use StdTomlMetaData.Bin instead.
+var StdTomlBin = StdTomlMetaData.Bin
+
+// DeployStdToml deploys a new Ethereum contract, binding an instance of StdToml to it.
+func DeployStdToml(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdToml, error) {
+	parsed, err := StdTomlMetaData.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(StdTomlBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &StdToml{StdTomlCaller: StdTomlCaller{contract: contract}, StdTomlTransactor: StdTomlTransactor{contract: contract}, StdTomlFilterer: StdTomlFilterer{contract: contract}}, nil
+}
+
+// StdToml is an auto generated Go binding around an Ethereum contract.
+type StdToml struct {
+	StdTomlCaller     // Read-only binding to the contract
+	StdTomlTransactor // Write-only binding to the contract
+	StdTomlFilterer   // Log filterer for contract events
+}
+
+// StdTomlCaller is an auto generated read-only Go binding around an Ethereum contract.
+type StdTomlCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdTomlTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type StdTomlTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdTomlFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type StdTomlFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// StdTomlSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type StdTomlSession struct {
+	Contract     *StdToml          // 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
+}
+
+// StdTomlCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type StdTomlCallerSession struct {
+	Contract *StdTomlCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts  // Call options to use throughout this session
+}
+
+// StdTomlTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type StdTomlTransactorSession struct {
+	Contract     *StdTomlTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
+}
+
+// StdTomlRaw is an auto generated low-level Go binding around an Ethereum contract.
+type StdTomlRaw struct {
+	Contract *StdToml // Generic contract binding to access the raw methods on
+}
+
+// StdTomlCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type StdTomlCallerRaw struct {
+	Contract *StdTomlCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// StdTomlTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type StdTomlTransactorRaw struct {
+	Contract *StdTomlTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewStdToml creates a new instance of StdToml, bound to a specific deployed contract.
+func NewStdToml(address common.Address, backend bind.ContractBackend) (*StdToml, error) {
+	contract, err := bindStdToml(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &StdToml{StdTomlCaller: StdTomlCaller{contract: contract}, StdTomlTransactor: StdTomlTransactor{contract: contract}, StdTomlFilterer: StdTomlFilterer{contract: contract}}, nil
+}
+
+// NewStdTomlCaller creates a new read-only instance of StdToml, bound to a specific deployed contract.
+func NewStdTomlCaller(address common.Address, caller bind.ContractCaller) (*StdTomlCaller, error) {
+	contract, err := bindStdToml(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdTomlCaller{contract: contract}, nil
+}
+
+// NewStdTomlTransactor creates a new write-only instance of StdToml, bound to a specific deployed contract.
+func NewStdTomlTransactor(address common.Address, transactor bind.ContractTransactor) (*StdTomlTransactor, error) {
+	contract, err := bindStdToml(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &StdTomlTransactor{contract: contract}, nil
+}
+
+// NewStdTomlFilterer creates a new log filterer instance of StdToml, bound to a specific deployed contract.
+func NewStdTomlFilterer(address common.Address, filterer bind.ContractFilterer) (*StdTomlFilterer, error) {
+	contract, err := bindStdToml(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &StdTomlFilterer{contract: contract}, nil
+}
+
+// bindStdToml binds a generic wrapper to an already deployed contract.
+func bindStdToml(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := StdTomlMetaData.GetAbi()
+	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 (_StdToml *StdTomlRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdToml.Contract.StdTomlCaller.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 (_StdToml *StdTomlRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdToml.Contract.StdTomlTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdToml *StdTomlRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdToml.Contract.StdTomlTransactor.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 (_StdToml *StdTomlCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _StdToml.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 (_StdToml *StdTomlTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _StdToml.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_StdToml *StdTomlTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _StdToml.Contract.contract.Transact(opts, method, params...)
+}
diff --git a/espressotee/nitro_verifier.go b/espressotee/nitro_verifier.go
new file mode 100644
index 00000000000..3d88a447787
--- /dev/null
+++ b/espressotee/nitro_verifier.go
@@ -0,0 +1,34 @@
+package espressotee
+
+import (
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+
+	"github.com/offchainlabs/nitro/espresso-tee-contracts/espressogen"
+)
+
+type EspressoNitroTEEVerifierInterface interface {
+	IsPCR0HashRegistered(pcr0Hash [32]byte) (bool, error)
+}
+
+type EspressoNitroTEEVerifier struct {
+	l1Client *ethclient.Client
+	address  common.Address
+}
+
+func NewEspressoNitroTEEVerifier(l1Client *ethclient.Client, nitroAddr common.Address) *EspressoNitroTEEVerifier {
+	return &EspressoNitroTEEVerifier{l1Client: l1Client, address: nitroAddr}
+}
+
+func (e *EspressoNitroTEEVerifier) IsPCR0HashRegistered(pcr0Hash [32]byte) (bool, error) {
+	return e.isPCR0HashRegistered(pcr0Hash)
+}
+
+func (e *EspressoNitroTEEVerifier) isPCR0HashRegistered(pcr0Hash [32]byte) (bool, error) {
+	contract, err := espressogen.NewEspressoNitroTEEVerifier(e.address, e.l1Client)
+	if err != nil {
+		return false, err
+	}
+	return contract.RegisteredEnclaveHash(&bind.CallOpts{}, pcr0Hash)
+}
diff --git a/espressotee/sgx_verifier.go b/espressotee/sgx_verifier.go
new file mode 100644
index 00000000000..f8e6fb92c43
--- /dev/null
+++ b/espressotee/sgx_verifier.go
@@ -0,0 +1,31 @@
+package espressotee
+
+import (
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+
+	"github.com/offchainlabs/nitro/espressotee/legacy"
+)
+
+type EspressoSGXVerifierInterface interface {
+	Verify(opts *bind.CallOpts, rawQuote []byte, reportDataHash [32]byte) (legacy.EnclaveReport, error)
+}
+
+type EspressoSGXVerifier struct {
+	verifier *legacy.IEspressoSGXTEEVerifier
+}
+
+func (v *EspressoSGXVerifier) Verify(opts *bind.CallOpts, rawQuote []byte, reportDataHash [32]byte) (legacy.EnclaveReport, error) {
+	return v.verifier.Verify(opts, rawQuote, reportDataHash)
+}
+
+func NewEspressoSGXVerifier(l1Client *ethclient.Client, addr common.Address) (*EspressoSGXVerifier, error) {
+	verifier, err := legacy.NewIEspressoSGXTEEVerifier(addr, l1Client)
+	if err != nil {
+		return nil, err
+	}
+	return &EspressoSGXVerifier{verifier: verifier}, nil
+}
+
+type EnclaveReport = legacy.EnclaveReport
diff --git a/espressotee/types.go b/espressotee/types.go
new file mode 100644
index 00000000000..f204e6a41c1
--- /dev/null
+++ b/espressotee/types.go
@@ -0,0 +1,12 @@
+package espressotee
+
+type ServiceType uint8
+
+const (
+	BatchPoster ServiceType = iota
+	CaffNode
+)
+
+const (
+	Test ServiceType = 255 // Add testing tag at 255 to avoid collisions as this is the least "real" option for a service type.
+)
diff --git a/execution/gethexec/espresso_utils.go b/execution/gethexec/espresso_utils.go
new file mode 100644
index 00000000000..36da462cb9a
--- /dev/null
+++ b/execution/gethexec/espresso_utils.go
@@ -0,0 +1,17 @@
+package gethexec
+
+import (
+	"time"
+
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+// Publish following functions for espresso caff node to access the blockchain
+func (s *ExecutionEngine) Bc() *core.BlockChain {
+	return s.bc
+}
+func (s *ExecutionEngine) AppendBlock(block *types.Block, statedb *state.StateDB, receipts types.Receipts, duration time.Duration) error {
+	return s.appendBlock(block, statedb, receipts, duration)
+}
diff --git a/flake.lock b/flake.lock
new file mode 100644
index 00000000000..760aac19195
--- /dev/null
+++ b/flake.lock
@@ -0,0 +1,237 @@
+{
+  "nodes": {
+    "flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1761588595,
+        "narHash": "sha256-XKUZz9zewJNUj46b4AJdiRZJAvSZ0Dqj2BNfXvFlJC4=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "f387cd2afec9419c8ee37694406ca490c3f34ee5",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "flake-compat_2": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1747046372,
+        "narHash": "sha256-CIVLLkVgvHYbgI2UpXvIIBJ12HWgX+fjA8Xf8PUmqCY=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "9100a0f413b0c601e0533d1d94ffd501ce2e7885",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "flake-utils_2": {
+      "locked": {
+        "lastModified": 1644229661,
+        "narHash": "sha256-1YdnJAsNy69bpcjuoKdOYQX0YxZBiCYZo4Twxerqv7k=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "3cecb5b042f7f209c56ffd8371b2711a290ec797",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "foundry": {
+      "inputs": {
+        "flake-utils": "flake-utils_2",
+        "nixpkgs": "nixpkgs"
+      },
+      "locked": {
+        "lastModified": 1759569036,
+        "narHash": "sha256-FuxbXLDArxD1NeRR8zNnsb8Xww5/+qdMwzN1m8Kow/M=",
+        "owner": "shazow",
+        "repo": "foundry.nix",
+        "rev": "47ba6d3b02bf3faaa857d3572df82ff186d5279a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "shazow",
+        "ref": "stable",
+        "repo": "foundry.nix",
+        "type": "github"
+      }
+    },
+    "gitignore": {
+      "inputs": {
+        "nixpkgs": [
+          "pre-commit-hooks",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1709087332,
+        "narHash": "sha256-HG2cCnktfHsKV0s4XW83gU3F57gaTljL9KNSuG6bnQs=",
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "rev": "637db329424fd7e46cf4185293b9cc8c88c95394",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1666753130,
+        "narHash": "sha256-Wff1dGPFSneXJLI2c0kkdWTgxnQ416KE6X4KnFkgPYQ=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "f540aeda6f677354f1e7144ab04352f61aaa0118",
+        "type": "github"
+      },
+      "original": {
+        "id": "nixpkgs",
+        "type": "indirect"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1762596750,
+        "narHash": "sha256-rXXuz51Bq7DHBlfIjN7jO8Bu3du5TV+3DSADBX7/9YQ=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "b6a8526db03f735b89dd5ff348f53f752e7ddc8e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_3": {
+      "locked": {
+        "lastModified": 1759417375,
+        "narHash": "sha256-O7eHcgkQXJNygY6AypkF9tFhsoDQjpNEojw3eFs73Ow=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "dc704e6102e76aad573f63b74c742cd96f8f1e6c",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_4": {
+      "locked": {
+        "lastModified": 1744536153,
+        "narHash": "sha256-awS2zRgF4uTwrOKwwiJcByDzDOdo3Q1rPZbiHQg/N38=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "18dd725c29603f582cf1900e0d25f9f1063dbf11",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "pre-commit-hooks": {
+      "inputs": {
+        "flake-compat": "flake-compat_2",
+        "gitignore": "gitignore",
+        "nixpkgs": "nixpkgs_3"
+      },
+      "locked": {
+        "lastModified": 1762441963,
+        "narHash": "sha256-j+rNQ119ffYUkYt2YYS6rnd6Jh/crMZmbqpkGLXaEt0=",
+        "owner": "cachix",
+        "repo": "pre-commit-hooks.nix",
+        "rev": "8e7576e79b88c16d7ee3bbd112c8d90070832885",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "repo": "pre-commit-hooks.nix",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "flake-utils": "flake-utils",
+        "foundry": "foundry",
+        "nixpkgs": "nixpkgs_2",
+        "pre-commit-hooks": "pre-commit-hooks",
+        "rust-overlay": "rust-overlay"
+      }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_4"
+      },
+      "locked": {
+        "lastModified": 1762828736,
+        "narHash": "sha256-RxtFHWZpKwVcWHhx88E2NhWuBbgYVqIoIDynGs5FoJs=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "8d5baa5628f6dbd7ce6beca3c299bae27755204c",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
\ No newline at end of file
diff --git a/flake.nix b/flake.nix
new file mode 100644
index 00000000000..ee51225212f
--- /dev/null
+++ b/flake.nix
@@ -0,0 +1,164 @@
+{
+  description = "A Nix-flake-based Nitro development environment";
+
+  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+  inputs.flake-utils.url = "github:numtide/flake-utils";
+  inputs.flake-compat.url = "github:edolstra/flake-compat";
+  inputs.flake-compat.flake = false;
+  inputs.rust-overlay.url = "github:oxalica/rust-overlay";
+  inputs.foundry.url = "github:shazow/foundry.nix/stable";
+  inputs.pre-commit-hooks.url = "github:cachix/pre-commit-hooks.nix";
+
+  outputs = { self, flake-utils, nixpkgs, foundry, rust-overlay, pre-commit-hooks, ... }:
+    let
+      goVersion = 25; # Change this to update the whole stack
+      overlays = [
+        (import rust-overlay)
+        (final: prev: rec {
+          go = prev."go_1_${toString goVersion}";
+          nodejs = prev.nodejs_24;
+          yarn = (prev.yarn.override { inherit nodejs; });
+          pnpm = (prev.pnpm.override { inherit nodejs; });
+        })
+        foundry.overlay
+      ];
+    in
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = import nixpkgs {
+          inherit overlays system;
+        };
+        stableToolchain = pkgs.rust-bin.stable."1.88.0".minimal.override {
+          extensions = [ "rustfmt" "clippy" "llvm-tools-preview" "rust-src" ];
+          targets = [ "wasm32-unknown-unknown" "wasm32-wasip1" ];
+        };
+        nightlyToolchain = pkgs.rust-bin.nightly."2024-12-17".minimal.override {
+          extensions = [ "rust-src" ];
+          targets = [ "wasm32-unknown-unknown" "wasm32-wasip1" ];
+        };
+        # A script that calls nightly cargo if invoked with `+nightly`
+        # as the first argument, otherwise it calls stable cargo.
+        cargo-with-nightly = pkgs.writeShellScriptBin "cargo" ''
+          if [[ "$1" == "+nightly" ]]; then
+            shift
+            # Prepend nightly toolchain directory containing cargo, rustc, etc.
+            exec env PATH="${nightlyToolchain}/bin:$PATH" cargo "$@"
+          fi
+          exec ${stableToolchain}/bin/cargo "$@"
+        '';
+        shellHook = ''
+          # Prevent cargo aliases from using programs in `~/.cargo` to avoid conflicts
+          # with rustup installations.
+          export CARGO_HOME=$HOME/.cargo-nix
+          export DOCKER_BUILDKIT=1
+
+          # Create a target directory and ensure lib64 is a symlink to lib.
+          # Individual build steps may target either directory and later
+          # create the symlink making some build outputs inaccessible.
+          mkdir -p target/lib
+          ln -sf lib target/lib64
+        ''
+        + pkgs.lib.optionalString pkgs.stdenv.isDarwin ''
+          # Fix docker-buildx command on OSX. Can we do this in a cleaner way?
+          mkdir -p ~/.docker/cli-plugins
+          # Check if the file exists, otherwise symlink
+          test -f $HOME/.docker/cli-plugins/docker-buildx || ln -sn $(which docker-buildx) $HOME/.docker/cli-plugins
+        '';
+      in
+      with pkgs; {
+        checks = {
+          pre-commit-check = pre-commit-hooks.lib.${system}.run {
+            src = ./.;
+            hooks = {
+              golangci-lint = {
+                enable = true;
+                entry = "golangci-lint run --new-from-rev=HEAD --fix";
+                pass_filenames = false;
+                types = [ "go" ];
+              };
+            };
+          };
+        };
+        devShells =
+          {
+            # mkShell brings in a `cc` that points to gcc, stdenv.mkDerivation from llvm avoids this.
+            default = let llvmPkgs = pkgs.llvmPackages; in llvmPkgs.stdenv.mkDerivation {
+              hardeningDisable = [
+                # By default stack protection is enabled by the clang wrapper but I
+                # think it's not supported for wasm compilation. It causes this
+                # error:
+                #
+                #   Undefined stack protector symbols: __stack_chk_guard ...
+                #   in arbitrator/wasm-libraries/soft-float/SoftFloat/build/Wasm-Clang/extF80_div.o
+                "stackprotector"
+                # See https://github.com/NixOS/nixpkgs/pull/256956#issuecomment-2351143479
+                "zerocallusedregs"
+              ];
+
+              name = "espresso-nitro-dev-shell";
+              buildInputs = with pkgs; [
+                cmake
+                cargo-with-nightly
+                stableToolchain
+                openssl
+                pkg-config
+
+                llvmPkgs.clang
+                llvmPkgs.bintools # provides wasm-ld
+
+                go
+                # goimports, godoc, etc.
+                gotools
+                golangci-lint
+                gotestsum
+
+                # Node
+                nodejs
+                yarn
+
+                python3
+                wget
+
+                # wasm
+                rust-cbindgen
+                wabt
+
+                # for dynamic linking
+                curl
+
+                # Docker
+                docker-compose # provides the `docker-compose` command
+                docker-buildx
+                docker-credential-helpers # for `docker-credential-osxkeychain` command
+
+                foundry-bin
+
+                # provides abigen
+                go-ethereum
+
+                # Needed to avoid some error on Linux related to glibc
+                git
+
+                # just
+                just
+
+                pre-commit
+              ] ++ lib.optionals stdenv.isDarwin [
+              ] ++ lib.optionals (! stdenv.isDarwin) [
+                glibc_multi.dev # provides gnu/stubs-32.h
+              ];
+              shellHook = shellHook + ''
+                export LIBCLANG_PATH="${llvmPkgs.libclang.lib}/lib"
+              ''
+                # Not sure why these lines are needed to avoid mixed SDK.
+                + pkgs.lib.optionalString pkgs.stdenv.isDarwin
+                ''
+                export SDKROOT="$SDKROOT_FOR_TARGET"
+                export DEVELOPER_DIR="$DEVELOPER_DIR_FOR_TARGET"
+                export MACOSX_DEPLOYMENT_TARGET=12.3
+                ''
+                + self.checks.${system}.pre-commit-check.shellHook;
+            };
+          };
+      });
+}
diff --git a/go-ethereum b/go-ethereum
index 9cc708bd459..41ab2f541e8 160000
--- a/go-ethereum
+++ b/go-ethereum
@@ -1 +1 @@
-Subproject commit 9cc708bd4599f7142f035d2d36c8da021d07a822
+Subproject commit 41ab2f541e8a3fdf8baaa51265c94161cc48b60a
diff --git a/go.mod b/go.mod
index c6929c56f31..51cb2d2ad48 100644
--- a/go.mod
+++ b/go.mod
@@ -7,21 +7,26 @@ replace github.com/ethereum/go-ethereum => ./go-ethereum
 require (
 	cloud.google.com/go/storage v1.43.0
 	github.com/DATA-DOG/go-sqlmock v1.5.2
+	github.com/EspressoSystems/espresso-network/sdks/go v0.3.4
 	github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible
 	github.com/Shopify/toxiproxy v2.1.4+incompatible
 	github.com/alicebob/miniredis/v2 v2.32.1
 	github.com/andybalholm/brotli v1.0.5
-	github.com/aws/aws-sdk-go-v2 v1.31.0
+	github.com/aws/aws-sdk-go-v2 v1.39.1
 	github.com/aws/aws-sdk-go-v2/config v1.27.40
 	github.com/aws/aws-sdk-go-v2/credentials v1.17.38
 	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.27
+	github.com/aws/aws-sdk-go-v2/service/kms v1.45.4
 	github.com/aws/aws-sdk-go-v2/service/s3 v1.64.1
 	github.com/cavaliergopher/grab/v3 v3.0.1
 	github.com/ccoveille/go-safecast v1.1.0
 	github.com/cockroachdb/pebble v1.1.5
 	github.com/codeclysm/extract/v3 v3.0.2
+	github.com/distributed-lab/enclave-extras/attestation v0.2.0
+	github.com/distributed-lab/enclave-extras/attestedkms v0.1.1
+	github.com/distributed-lab/enclave-extras/nsm v0.2.0
 	github.com/enescakir/emoji v1.0.0
-	github.com/ethereum/go-ethereum v1.16.2
+	github.com/ethereum/go-ethereum v1.16.3
 	github.com/fatih/structtag v1.2.0
 	github.com/gdamore/tcell/v2 v2.7.1
 	github.com/gobwas/httphead v0.1.0
@@ -32,11 +37,15 @@ require (
 	github.com/google/go-cmp v0.6.0
 	github.com/google/uuid v1.6.0
 	github.com/hashicorp/golang-lru/v2 v2.0.7
+	github.com/hf/nitrite v0.0.0-20241225144000-c2d5d3c4f303
+	github.com/hf/nsm v0.0.0-20220930140112-cd181bd646b9
 	github.com/holiman/uint256 v1.3.2
 	github.com/jmoiron/sqlx v1.4.0
 	github.com/knadh/koanf v1.4.0
 	github.com/mailru/easygo v0.0.0-20190618140210-3c14a0dc985f
 	github.com/mattn/go-sqlite3 v1.14.22
+	github.com/miguelmota/go-ethereum-hdwallet v0.1.3
+	github.com/minio/sha256-simd v1.0.1
 	github.com/mitchellh/mapstructure v1.4.1
 	github.com/pkg/errors v0.9.1
 	github.com/r3labs/diff/v3 v3.0.1
@@ -47,26 +56,36 @@ require (
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7
 	github.com/wealdtech/go-merkletree v1.0.0
 	go.uber.org/automaxprocs v1.5.2
-	golang.org/x/crypto v0.36.0
-	golang.org/x/sync v0.12.0
+	golang.org/x/crypto v0.40.0
+	golang.org/x/sync v0.16.0
 	golang.org/x/sys v0.36.0
-	golang.org/x/term v0.30.0
-	golang.org/x/tools v0.29.0
+	golang.org/x/term v0.33.0
+	golang.org/x/tools v0.34.0
 	google.golang.org/api v0.187.0
 	gopkg.in/natefinch/lumberjack.v2 v2.2.1
 )
 
+require (
+	github.com/fxamacker/cbor/v2 v2.7.0 // indirect
+	github.com/x448/float16 v0.8.4 // indirect
+)
+
 require (
 	cloud.google.com/go v0.115.0 // indirect
 	cloud.google.com/go/auth v0.6.1 // indirect
 	cloud.google.com/go/auth/oauth2adapt v0.2.2 // indirect
 	cloud.google.com/go/compute/metadata v0.3.0 // indirect
 	cloud.google.com/go/iam v1.1.8 // indirect
+	github.com/btcsuite/btcd v0.24.0 // indirect
+	github.com/btcsuite/btcd/btcec/v2 v2.2.0 // indirect
+	github.com/btcsuite/btcd/btcutil v1.1.5 // indirect
+	github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 // indirect
 	github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce // indirect
+	github.com/coder/websocket v1.8.14 // indirect
 	github.com/crate-crypto/go-eth-kzg v1.4.0 // indirect
 	github.com/dchest/siphash v1.2.3 // indirect
 	github.com/emicklei/dot v1.6.2 // indirect
-	github.com/ethereum/c-kzg-4844/v2 v2.1.3 // indirect
+	github.com/ethereum/c-kzg-4844/v2 v2.1.5 // indirect
 	github.com/ethereum/go-bigmodexpfix v0.0.0-20250911101455-f9e208c548ab // indirect
 	github.com/ethereum/go-verkle v0.2.2 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
@@ -79,21 +98,22 @@ require (
 	github.com/google/s2a-go v0.1.7 // indirect
 	github.com/googleapis/enterprise-certificate-proxy v0.3.2 // indirect
 	github.com/googleapis/gax-go/v2 v2.12.5 // indirect
-	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
-	github.com/minio/sha256-simd v1.0.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.3 // indirect
 	github.com/pion/dtls/v2 v2.2.7 // indirect
 	github.com/pion/logging v0.2.2 // indirect
 	github.com/pion/stun/v2 v2.0.0 // indirect
 	github.com/pion/transport/v2 v2.2.1 // indirect
 	github.com/pion/transport/v3 v3.0.1 // indirect
+	github.com/sigurn/crc8 v0.0.0-20220107193325-2243fe600f9f // indirect
 	github.com/stretchr/objx v0.5.2 // indirect
+	github.com/tyler-smith/go-bip39 v1.1.0 // indirect
 	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0 // indirect
 	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 // indirect
 	go.opentelemetry.io/otel v1.24.0 // indirect
 	go.opentelemetry.io/otel/metric v1.24.0 // indirect
 	go.opentelemetry.io/otel/trace v1.24.0 // indirect
 	golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect
-	golang.org/x/text v0.23.0 // indirect
+	golang.org/x/text v0.27.0 // indirect
 	golang.org/x/time v0.9.0 // indirect
 	google.golang.org/genproto v0.0.0-20240624140628-dc46fd24d27d // indirect
 	google.golang.org/genproto/googleapis/api v0.0.0-20240617180043-68d350f18fd4 // indirect
@@ -110,19 +130,19 @@ require (
 	github.com/VictoriaMetrics/fastcache v1.13.0 // indirect
 	github.com/alicebob/gopher-json v0.0.0-20200520072559-a9ecdc9d1d3a // indirect
 	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.5 // indirect
-	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.14 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.18 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.18 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.14
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.8 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.8 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.18 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.5 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.20 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.20 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.8 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.18 // indirect
 	github.com/aws/aws-sdk-go-v2/service/sso v1.23.4 // indirect
 	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.27.4 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sts v1.31.4 // indirect
-	github.com/aws/smithy-go v1.22.0 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.38.5
+	github.com/aws/smithy-go v1.23.0 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/bits-and-blooms/bitset v1.20.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
@@ -196,7 +216,7 @@ require (
 	github.com/yuin/gopher-lua v1.1.1 // indirect
 	github.com/yusufpapurcu/wmi v1.2.2 // indirect
 	go.opencensus.io v0.24.0 // indirect
-	golang.org/x/mod v0.22.0 // indirect
-	golang.org/x/net v0.38.0 // indirect
+	golang.org/x/mod v0.25.0
+	golang.org/x/net v0.41.0 // indirect
 	golang.org/x/oauth2 v0.27.0
 )
diff --git a/go.sum b/go.sum
index 7c9a4e344e1..a585a741888 100644
--- a/go.sum
+++ b/go.sum
@@ -20,6 +20,8 @@ github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7Oputl
 github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU=
 github.com/DataDog/zstd v1.5.2 h1:vUG4lAyuPCXO0TLbXvPv7EB7cNK1QV/luu55UHLrrn8=
 github.com/DataDog/zstd v1.5.2/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw=
+github.com/EspressoSystems/espresso-network/sdks/go v0.3.4 h1:1hf/k2rGqIGEGQW8O3fQFltPIyxSmumph8aKIa6AjCk=
+github.com/EspressoSystems/espresso-network/sdks/go v0.3.4/go.mod h1:kaxR08mJb5Mijy7a2RhWCIWOevFI4PcXwDkzoEbsVTk=
 github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible h1:1G1pk05UrOh0NlF1oeaaix1x8XzrfjIDK47TY0Zehcw=
 github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
 github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
@@ -28,6 +30,7 @@ github.com/Shopify/toxiproxy v2.1.4+incompatible h1:TKdv8HiTLgE5wdJuEML90aBgNWso
 github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
 github.com/VictoriaMetrics/fastcache v1.13.0 h1:AW4mheMR5Vd9FkAPUv+NH6Nhw+fmbTMGMsNAoA/+4G0=
 github.com/VictoriaMetrics/fastcache v1.13.0/go.mod h1:hHXhl4DA2fTL2HTZDJFXWgW0LNjo6B+4aj2Wmng3TjU=
+github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
 github.com/alicebob/gopher-json v0.0.0-20200520072559-a9ecdc9d1d3a h1:HbKu58rmZpUGpz5+4FfNmIU+FmZg2P3Xaj2v2bfNWmk=
 github.com/alicebob/gopher-json v0.0.0-20200520072559-a9ecdc9d1d3a/go.mod h1:SGnFV6hVsYE877CKEZ6tDNTjaSXYUk6QqoIK6PrAtcc=
 github.com/alicebob/miniredis/v2 v2.32.1 h1:Bz7CciDnYSaa0mX5xODh6GUITRSx+cVhjNoOR4JssBo=
@@ -41,8 +44,8 @@ github.com/arduino/go-paths-helper v1.2.0/go.mod h1:HpxtKph+g238EJHq4geEPv9p+gl3
 github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
 github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
 github.com/aws/aws-sdk-go-v2 v1.9.2/go.mod h1:cK/D0BBs0b/oWPIcX/Z/obahJK1TT7IPVjy53i/mX/4=
-github.com/aws/aws-sdk-go-v2 v1.31.0 h1:3V05LbxTSItI5kUqNwhJrrrY1BAXxXt0sN0l72QmG5U=
-github.com/aws/aws-sdk-go-v2 v1.31.0/go.mod h1:ztolYtaEUtdpf9Wftr31CJfLVjOnD/CVRkKOOYgF8hA=
+github.com/aws/aws-sdk-go-v2 v1.39.1 h1:fWZhGAwVRK/fAN2tmt7ilH4PPAE11rDj7HytrmbZ2FE=
+github.com/aws/aws-sdk-go-v2 v1.39.1/go.mod h1:sDioUELIUO9Znk23YVmIk86/9DOpkbyyVb1i/gUNFXY=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.5 h1:xDAuZTn4IMm8o1LnBZvmrL8JA1io4o3YWNXgohbf20g=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.5/go.mod h1:wYSv6iDS621sEFLfKvpPE2ugjTuGlAG7iROg0hLOkfc=
 github.com/aws/aws-sdk-go-v2/config v1.8.3/go.mod h1:4AEiLtAb8kLs7vgw2ZV3p2VZ1+hBavOc84hqxVNpCyw=
@@ -56,25 +59,27 @@ github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.14 h1:C/d03NAmh8C4BZXhuRNboF
 github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.14/go.mod h1:7I0Ju7p9mCIdlrfS+JCgqcYD0VXz/N4yozsox+0o078=
 github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.27 h1:1oLpQSTuqbizOUEYdxAwH+Eveg+FOCOkg84Yijba6Kc=
 github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.27/go.mod h1:afo0vF9P3pjy1ny+cb45lzBjtKeEb5t5MPRxeTXpujw=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.18 h1:kYQ3H1u0ANr9KEKlGs/jTLrBFPo8P8NaH/w7A01NeeM=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.18/go.mod h1:r506HmK5JDUh9+Mw4CfGJGSSoqIiLCndAuqXuhbv67Y=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.18 h1:Z7IdFUONvTcvS7YuhtVxN99v2cCoHRXOS4mTr0B/pUc=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.18/go.mod h1:DkKMmksZVVyat+Y+r1dEOgJEfUeA7UngIHWeKsi0yNc=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.8 h1:6bgAZgRyT4RoFWhxS+aoGMFyE0cD1bSzFnEEi4bFPGI=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.8/go.mod h1:KcGkXFVU8U28qS4KvLEcPxytPZPBcRawaH2Pf/0jptE=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.8 h1:HhJYoES3zOz34yWEpGENqJvRVPqpmJyR3+AFg9ybhdY=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.8/go.mod h1:JnA+hPWeYAVbDssp83tv+ysAG8lTfLVXvSsyKg/7xNA=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.2.4/go.mod h1:ZcBrrI3zBKlhGFNYWvju0I3TR93I7YIgAfy82Fh4lcQ=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 h1:VaRN3TlFdd6KxX1x3ILT5ynH6HvKgqdiXoTxAF4HQcQ=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1/go.mod h1:FbtygfRFze9usAadmnGJNc8KsP346kEe+y2/oyhGAGc=
 github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.18 h1:OWYvKL53l1rbsUmW7bQyJVsYU/Ii3bbAAQIIFNbM0Tk=
 github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.18/go.mod h1:CUx0G1v3wG6l01tUB+j7Y8kclA8NSqK4ef0YG79a4cg=
 github.com/aws/aws-sdk-go-v2/service/appconfig v1.4.2/go.mod h1:FZ3HkCe+b10uFZZkFdvf98LHW21k49W8o8J366lqVKY=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.5 h1:QFASJGfT8wMXtuP3D5CRmMjARHv9ZmzFUMJznHDOY3w=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.5/go.mod h1:QdZ3OmoIjSX+8D1OPAzPxDfjXASbBMDsz9qvtyIhtik=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.1 h1:oegbebPEMA/1Jny7kvwejowCaHz1FWZAQ94WXFNCyTM=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.1/go.mod h1:kemo5Myr9ac0U9JfSjMo9yHLtw+pECEHsFtJ9tqCEI8=
 github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.20 h1:rTWjG6AvWekO2B1LHeM3ktU7MqyX9rzWQ7hgzneZW7E=
 github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.20/go.mod h1:RGW2DDpVc8hu6Y6yG8G5CHVmVOAn1oV8rNKOHRJyswg=
 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.3.2/go.mod h1:72HRZDLMtmVQiLG2tLfQcaWLCssELvGl+Zf2WVxMmR8=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.20 h1:Xbwbmk44URTiHNx6PNo0ujDE6ERlsCKJD3u1zfnzAPg=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.20/go.mod h1:oAfOFzUB14ltPZj1rWwRc3d/6OgD76R8KlvU3EqM9Fg=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.8 h1:M6JI2aGFEzYxsF6CXIuRBnkge9Wf9a2xU39rNeXgu10=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.8/go.mod h1:Fw+MyTwlwjFsSTE31mH211Np+CUslml8mzc0AFEG09s=
 github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.18 h1:eb+tFOIl9ZsUe2259/BKPeniKuz4/02zZFH/i4Nf8Rg=
 github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.18/go.mod h1:GVCC2IJNJTmdlyEsSmofEy7EfJncP7DNnXDzRjJ5Keg=
+github.com/aws/aws-sdk-go-v2/service/kms v1.45.4 h1:6gzIbiRNs6o/K/WaLta0Vwac0bI9ou3gfx8ASSMf3wU=
+github.com/aws/aws-sdk-go-v2/service/kms v1.45.4/go.mod h1:ooAdc5n3rjgEznIXncCYY6V9+YQDcJAYyZDJ4TwLSDM=
 github.com/aws/aws-sdk-go-v2/service/s3 v1.64.1 h1:jjHf+M6vCp/WzbyFEroY4/Nx8dJac520A0EPwlYk0Do=
 github.com/aws/aws-sdk-go-v2/service/s3 v1.64.1/go.mod h1:NLTqRLe3pUNu3nTEHI6XlHLKYmc8fbHUdMxAB6+s41Q=
 github.com/aws/aws-sdk-go-v2/service/sso v1.4.2/go.mod h1:NBvT9R1MEF+Ud6ApJKM0G+IkPchKS7p7c2YPKwHmBOk=
@@ -83,11 +88,11 @@ github.com/aws/aws-sdk-go-v2/service/sso v1.23.4/go.mod h1:XRlMvmad0ZNL+75C5FYdM
 github.com/aws/aws-sdk-go-v2/service/ssooidc v1.27.4 h1:4f2/JKYZHAZbQ7koBpZ012bKi32NHPY0m7TDuJgsbug=
 github.com/aws/aws-sdk-go-v2/service/ssooidc v1.27.4/go.mod h1:FnvDM4sfa+isJ3kDXIzAB9GAwVSzFzSy97uZ3IsHo4E=
 github.com/aws/aws-sdk-go-v2/service/sts v1.7.2/go.mod h1:8EzeIqfWt2wWT4rJVu3f21TfrhJ8AEMzVybRNSb/b4g=
-github.com/aws/aws-sdk-go-v2/service/sts v1.31.4 h1:uK6dUUdJtqutK1XO/tmNaQMJiPLCJY/eAeOOmqQ6ygY=
-github.com/aws/aws-sdk-go-v2/service/sts v1.31.4/go.mod h1:yMWe0F+XG0DkRZK5ODZhG7BEFYhLXi2dqGsv6tX0cgI=
+github.com/aws/aws-sdk-go-v2/service/sts v1.38.5 h1:+LVB0xBqEgjQoqr9bGZbRzvg212B0f17JdflleJRNR4=
+github.com/aws/aws-sdk-go-v2/service/sts v1.38.5/go.mod h1:xoaxeqnnUaZjPjaICgIy5B+MHCSb/ZSOn4MvkFNOUA0=
 github.com/aws/smithy-go v1.8.0/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E=
-github.com/aws/smithy-go v1.22.0 h1:uunKnWlcoL3zO7q+gG2Pk53joueEOsnNB28QdMsmiMM=
-github.com/aws/smithy-go v1.22.0/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
+github.com/aws/smithy-go v1.23.0 h1:8n6I3gXzWJB2DxBDnfxgBaSX6oe0d/t10qGz7OKqMCE=
+github.com/aws/smithy-go v1.23.0/go.mod h1:t1ufH5HMublsJYulve2RKmHDC15xu1f26kHCp/HgceI=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
@@ -97,6 +102,32 @@ github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
 github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
 github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
 github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
+github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ=
+github.com/btcsuite/btcd v0.22.0-beta.0.20220111032746-97732e52810c/go.mod h1:tjmYdS6MLJ5/s0Fj4DbLgSbDHbEqLJrtnHecBFkdz5M=
+github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd/go.mod h1:nm3Bko6zh6bWP60UxwoT5LzdGJsQJaPo6HjduXq9p6A=
+github.com/btcsuite/btcd v0.24.0 h1:gL3uHE/IaFj6fcZSu03SvqPMSx7s/dPzfpG/atRwWdo=
+github.com/btcsuite/btcd v0.24.0/go.mod h1:K4IDc1593s8jKXIF7yS7yCTSxrknB9z0STzc2j6XgE4=
+github.com/btcsuite/btcd/btcec/v2 v2.1.0/go.mod h1:2VzYrv4Gm4apmbVVsSq5bqf1Ec8v56E48Vt0Y/umPgA=
+github.com/btcsuite/btcd/btcec/v2 v2.1.3/go.mod h1:ctjw4H1kknNJmRN4iP1R7bTQ+v3GJkZBd6mui8ZsAZE=
+github.com/btcsuite/btcd/btcec/v2 v2.2.0 h1:fzn1qaOt32TuLjFlkzYSsBC35Q3KUjT1SwPxiMSCF5k=
+github.com/btcsuite/btcd/btcec/v2 v2.2.0/go.mod h1:U7MHm051Al6XmscBQ0BoNydpOTsFAn707034b5nY8zU=
+github.com/btcsuite/btcd/btcutil v1.0.0/go.mod h1:Uoxwv0pqYWhD//tfTiipkxNfdhG9UrLwaeswfjfdF0A=
+github.com/btcsuite/btcd/btcutil v1.1.0/go.mod h1:5OapHB7A2hBBWLm48mmw4MOHNJCcUBTwmWH/0Jn8VHE=
+github.com/btcsuite/btcd/btcutil v1.1.5 h1:+wER79R5670vs/ZusMTF1yTcRYE5GUsFbdjdisflzM8=
+github.com/btcsuite/btcd/btcutil v1.1.5/go.mod h1:PSZZ4UitpLBWzxGd5VGOrLnmOjtPP/a6HaFo12zMs00=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.0.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 h1:59Kx4K6lzOW5w6nFlA0v5+lk/6sjybR934QNHSJZPTQ=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
+github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA=
+github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg=
+github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg=
+github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY=
+github.com/btcsuite/goleveldb v1.0.0/go.mod h1:QiK9vBlgftBg6rWQIj6wFzbPfRjiykIEhBH4obrXJ/I=
+github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc=
+github.com/btcsuite/snappy-go v1.0.0/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc=
+github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY=
+github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs=
 github.com/cavaliergopher/grab/v3 v3.0.1 h1:4z7TkBfmPjmLAAmkkAZNX/6QJ1nNFdv3SdIHXju0Fr4=
 github.com/cavaliergopher/grab/v3 v3.0.1/go.mod h1:1U/KNnD+Ft6JJiYoYBAimKH2XrYptb8Kl3DFGmsjpq4=
 github.com/ccoveille/go-safecast v1.1.0 h1:iHKNWaZm+OznO7Eh6EljXPjGfGQsSfa6/sxPlIEKO+g=
@@ -130,6 +161,8 @@ github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAK
 github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ=
 github.com/codeclysm/extract/v3 v3.0.2 h1:sB4LcE3Php7LkhZwN0n2p8GCwZe92PEQutdbGURf5xc=
 github.com/codeclysm/extract/v3 v3.0.2/go.mod h1:NKsw+hqua9H+Rlwy/w/3Qgt9jDonYEgB6wJu+25eOKw=
+github.com/coder/websocket v1.8.14 h1:9L0p0iKiNOibykf283eHkKUHHrpG7f65OE3BhhO7v9g=
+github.com/coder/websocket v1.8.14/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
 github.com/consensys/gnark-crypto v0.18.1 h1:RyLV6UhPRoYYzaFnPQA4qK3DyuDgkTgskDdoGqFt3fI=
 github.com/consensys/gnark-crypto v0.18.1/go.mod h1:L3mXGFTe1ZN+RSJ+CLjUt9x7PNdx8ubaYfDROyp2Z8c=
 github.com/cpuguy83/go-md2man/v2 v2.0.5 h1:ZtcqGrnekaHpVLArFSe4HK5DoKx1T0rq2DwVB0alcyc=
@@ -139,6 +172,7 @@ github.com/crate-crypto/go-eth-kzg v1.4.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn
 github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a h1:W8mUrRp6NOVl3J+MYp5kPMoUZPp7aOYHtaua31lwRHg=
 github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a/go.mod h1:sTwzHBvIzm2RfVCGNEBZgRyjwK40bVoun3ZnGOCafNM=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -146,14 +180,23 @@ github.com/dchest/siphash v1.2.3 h1:QXwFc8cFOR2dSa/gE6o/HokBMWtLUaNDVd+22aKHeEA=
 github.com/dchest/siphash v1.2.3/go.mod h1:0NvQU092bT0ipiFN++/rXm69QG9tVxLAlQHIXMPAkHc=
 github.com/deckarep/golang-set/v2 v2.6.0 h1:XfcQbWM1LlMB8BsJ8N9vW5ehnnPVIw0je80NsVHagjM=
 github.com/deckarep/golang-set/v2 v2.6.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4=
+github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
 github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y=
 github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0=
+github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218=
 github.com/deepmap/oapi-codegen v1.6.0 h1:w/d1ntwh91XI0b/8ja7+u5SvA4IFfM0UNNLmiDR1gg0=
 github.com/deepmap/oapi-codegen v1.6.0/go.mod h1:ryDa9AgbELGeB+YEXE1dR53yAjHwFvE9iAUlWl9Al3M=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
+github.com/distributed-lab/enclave-extras/attestation v0.2.0 h1:YGbZifn4w3WUaOvnAtqUyvN00WTSw1yYkpT22LGYtuo=
+github.com/distributed-lab/enclave-extras/attestation v0.2.0/go.mod h1:4iDbRB5M7yr8awG42cr1lKFldhK6V5sKusFLEhK1fcU=
+github.com/distributed-lab/enclave-extras/attestedkms v0.1.1 h1:HcM7gq4m1uTtwJjxTSY0YGo5Rud3HLEBcJrFRmw9H8M=
+github.com/distributed-lab/enclave-extras/attestedkms v0.1.1/go.mod h1:ilCjHdcAxjarL3xzOGKfIk/AWnjWytzCt233U84IoZQ=
+github.com/distributed-lab/enclave-extras/nsm v0.2.0 h1:exHPTGffHwuj2BYZwSo0EcOWV2Cmy2v6Q3VkbohZ4xw=
+github.com/distributed-lab/enclave-extras/nsm v0.2.0/go.mod h1:NI0pBNPy/O4lN6B9dW/1yXwBnNfaJc9OFGhpDAY0hnk=
 github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
 github.com/dlclark/regexp2 v1.7.0 h1:7lJfhqlPssTb1WQx4yvTHN0uElPEv52sbaECrAQxjAo=
 github.com/dlclark/regexp2 v1.7.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
@@ -170,8 +213,8 @@ github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymF
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/ethereum/c-kzg-4844/v2 v2.1.3 h1:DQ21UU0VSsuGy8+pcMJHDS0CV1bKmJmxsJYK8l3MiLU=
-github.com/ethereum/c-kzg-4844/v2 v2.1.3/go.mod h1:fyNcYI/yAuLWJxf4uzVtS8VDKeoAaRM8G/+ADz/pRdA=
+github.com/ethereum/c-kzg-4844/v2 v2.1.5 h1:aVtoLK5xwJ6c5RiqO8g8ptJ5KU+2Hdquf6G3aXiHh5s=
+github.com/ethereum/c-kzg-4844/v2 v2.1.5/go.mod h1:u59hRTTah4Co6i9fDWtiCjTrblJv0UwsqZKCc0GfgUs=
 github.com/ethereum/go-bigmodexpfix v0.0.0-20250911101455-f9e208c548ab h1:rvv6MJhy07IMfEKuARQ9TKojGqLVNxQajaXEp/BoqSk=
 github.com/ethereum/go-bigmodexpfix v0.0.0-20250911101455-f9e208c548ab/go.mod h1:IuLm4IsPipXKF7CW5Lzf68PIbZ5yl7FFd74l/E0o9A8=
 github.com/ethereum/go-verkle v0.2.2 h1:I2W0WjnrFUIzzVPwm8ykY+7pL2d4VhlsePn4j7cnFk8=
@@ -188,6 +231,9 @@ github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMo
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
 github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
+github.com/fxamacker/cbor/v2 v2.2.0/go.mod h1:TA1xS00nchWmaBnEIxPSE5oHLuJBAVvqrtAnWBwBCVo=
+github.com/fxamacker/cbor/v2 v2.7.0 h1:iM5WgngdRBanHcxugY4JySA0nk1wZorNOpTgCMedv5E=
+github.com/fxamacker/cbor/v2 v2.7.0/go.mod h1:pxXPTn3joSm21Gbwsv0w9OSA2y1HFR9qXEeXQVeNoDQ=
 github.com/gammazero/deque v1.1.0 h1:OyiyReBbnEG2PP0Bnv1AASLIYvyKqIFN5xfl1t8oGLo=
 github.com/gammazero/deque v1.1.0/go.mod h1:JVrR+Bj1NMQbPnYclvDlvSX0nVGReLrQZ0aUMuWLctg=
 github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
@@ -317,6 +363,10 @@ github.com/hashicorp/vault/api v1.0.4/go.mod h1:gDcqh3WGcR1cpF5AJz/B1UFheUEneMoI
 github.com/hashicorp/vault/sdk v0.1.13/go.mod h1:B+hVj7TpuQY1Y/GPbCpffmgd+tSEwvhkWnjtSYCaS2M=
 github.com/hashicorp/yamux v0.0.0-20180604194846-3520598351bb/go.mod h1:+NfK9FKeTrX5uv1uIXGdwYDTeHna2qgaIlx54MXqjAM=
 github.com/hashicorp/yamux v0.0.0-20181012175058-2f1d1f20f75d/go.mod h1:+NfK9FKeTrX5uv1uIXGdwYDTeHna2qgaIlx54MXqjAM=
+github.com/hf/nitrite v0.0.0-20241225144000-c2d5d3c4f303 h1:XBSq4rXFUgD8ic6Mr7dBwJN/47yg87XpZQhiknfr4Cg=
+github.com/hf/nitrite v0.0.0-20241225144000-c2d5d3c4f303/go.mod h1:ycRhVmo6wegyEl6WN+zXOHUTJvB0J2tiuH88q/McTK8=
+github.com/hf/nsm v0.0.0-20220930140112-cd181bd646b9 h1:pU32bJGmZwF4WXb9Yaz0T8vHDtIPVxqDOdmYdwTQPqw=
+github.com/hf/nsm v0.0.0-20220930140112-cd181bd646b9/go.mod h1:MJsac5D0fKcNWfriUERtln6segcGfD6Nu0V5uGBbPf8=
 github.com/holiman/billy v0.0.0-20250707135307-f2f9b9aae7db h1:IZUYC/xb3giYwBLMnr8d0TGTzPKFGNTCGgGLoyeX330=
 github.com/holiman/billy v0.0.0-20250707135307-f2f9b9aae7db/go.mod h1:xTEYN9KCHxuYHs+NmrmzFcnvHMzLLNiGFafCb1n3Mfg=
 github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
@@ -335,12 +385,15 @@ github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839 h1:W9WBk7
 github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo=
 github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus=
 github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
+github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
 github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
 github.com/jmoiron/sqlx v1.4.0 h1:1PLqN7S1UYp5t4SrVVnt4nUVNemrDAtxlulVe+Qgm3o=
 github.com/jmoiron/sqlx v1.4.0/go.mod h1:ZrZ7UsYB/weZdl2Bxg6jCRO9c3YHl8r3ahlKmRT4JLY=
 github.com/joho/godotenv v1.3.0 h1:Zjp+RcGpHhGlrMbJzXTrZZPrWj+1vfm90La1wgB6Bhc=
 github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg=
+github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
 github.com/juju/clock v0.0.0-20180524022203-d293bb356ca4/go.mod h1:nD0vlnrUjcjJhqN5WuCWZyzfd5AHZAC9/ajvbSx69xA=
 github.com/juju/errors v0.0.0-20150916125642-1b5e39b83d18/go.mod h1:W54LbzXuIE0boCoNJfwqpmkKJ1O4TCTZMetAt6jGk7Q=
 github.com/juju/errors v0.0.0-20181118221551-089d3ea4e4d5 h1:rhqTjzJlm7EbkELJDKMTU7udov+Se0xZkWmugr6zGok=
@@ -356,11 +409,11 @@ github.com/juju/version v0.0.0-20161031051906-1f41e27e54f2/go.mod h1:kE8gK5X0CIm
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46/go.mod h1:yyMNCyc/Ib3bDTKd379tNMpB/7/H5TjM2Y9QJ5THLbE=
+github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4=
 github.com/klauspost/compress v1.17.2 h1:RlWWUY/Dr4fL8qk9YG7DTZ7PDgME2V4csBXA8L/ixi4=
 github.com/klauspost/compress v1.17.2/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
-github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4=
-github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.3 h1:sxCkb+qR91z4vsqw4vGGZlDgPz3G7gjaLyK3V8y70BU=
+github.com/klauspost/cpuid/v2 v2.2.3/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
 github.com/knadh/koanf v1.4.0 h1:/k0Bh49SqLyLNfte9r6cvuZWrApOQhglOmhIU3L/zDw=
 github.com/knadh/koanf v1.4.0/go.mod h1:1cfH5223ZeZUOs8FU2UdTmaNfHpqgtjV0+NHjRO43gs=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@@ -396,8 +449,10 @@ github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
 github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
-github.com/minio/sha256-simd v1.0.0 h1:v1ta+49hkWZyvaKwrQB8elexRqm6Y0aMLjCNsrYxo6g=
-github.com/minio/sha256-simd v1.0.0/go.mod h1:OuYzVNI5vcoYIAmbIvHPl3N3jUzVedXbKy5RFepssQM=
+github.com/miguelmota/go-ethereum-hdwallet v0.1.3 h1:YO/zmmdfM1hPPI8ZLg/UMm/s4M09j9ozXsjJO4s5efc=
+github.com/miguelmota/go-ethereum-hdwallet v0.1.3/go.mod h1:rdfIHQY4mIL1LF8HPUc9AchObyOpN/ElXBgyvlZL0OQ=
+github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM=
+github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8=
 github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
 github.com/mitchellh/copystructure v1.0.0/go.mod h1:SNtv71yrdKgLRyLFxmLdkAbkKEFWgYaq1OVrnRcwhnw=
 github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw=
@@ -422,9 +477,12 @@ github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQ
 github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
 github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
 github.com/onsi/ginkgo v1.14.0 h1:2mOpI4JVVPBN+WQRa0WKH2eXR+Ey+uK4n7Zj0aYpIQA=
 github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
+github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
+github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
@@ -491,6 +549,8 @@ github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFo
 github.com/ryanuber/go-glob v1.0.0/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
 github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
+github.com/sigurn/crc8 v0.0.0-20220107193325-2243fe600f9f h1:1R9KdKjCNSd7F8iGTxIpoID9prlYH8nuNYKt0XvweHA=
+github.com/sigurn/crc8 v0.0.0-20220107193325-2243fe600f9f/go.mod h1:vQhwQ4meQEDfahT5kd61wLAF5AAeh5ZPLVI4JJ/tYo8=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
 github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
@@ -518,6 +578,8 @@ github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFA
 github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI=
 github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk=
 github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY=
+github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
+github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
 github.com/urfave/cli/v2 v2.27.5 h1:WoHEJLdsXr6dDWoJgMq/CboDmyY/8HMMH1fTECbih+w=
 github.com/urfave/cli/v2 v2.27.5/go.mod h1:3Sevf16NykTbInEnD0yKkjDAeZDS0A6bzhBH5hrMvTQ=
 github.com/vmihailenco/msgpack/v5 v5.3.5 h1:5gO0H1iULLWGhs2H5tbAHIZTV8/cYafcFOr9znI5mJU=
@@ -526,6 +588,8 @@ github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAh
 github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
 github.com/wealdtech/go-merkletree v1.0.0 h1:DsF1xMzj5rK3pSQM6mPv8jlyJyHXhFxpnA2bwEjMMBY=
 github.com/wealdtech/go-merkletree v1.0.0/go.mod h1:cdil512d/8ZC7Kx3bfrDvGMQXB25NTKbsm0rFrmDax4=
+github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
+github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
 github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4=
 github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -553,6 +617,7 @@ go.uber.org/automaxprocs v1.5.2 h1:2LxUOGiR3O6tw8ui5sZa2LAaHnsviZdVOUZw4fvbnME=
 go.uber.org/automaxprocs v1.5.2/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20180214000028-650f4a345ab4/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
@@ -560,21 +625,24 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
 golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
-golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
-golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
+golang.org/x/crypto v0.40.0 h1:r4x+VvoG5Fm+eJcxMaY8CQM7Lb0l1lsmjGBQ6s8BfKM=
+golang.org/x/crypto v0.40.0/go.mod h1:Qr1vMER5WyS2dfPHAlsOj01wgLbsyWtFn/aY+5+ZdxY=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ=
 golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4=
-golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
+golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=
+golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
 golang.org/x/net v0.0.0-20180406214816-61147c48b25b/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -593,8 +661,8 @@ golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
 golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
 golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
-golang.org/x/net v0.38.0 h1:vRMAPTMaeGqVhG5QyLJHqNDwecKTomGeqbnfZyKlBI8=
-golang.org/x/net v0.38.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
+golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
+golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.27.0 h1:da9Vo7/tDv5RH/7nZDz1eMGS/q1Vv1N/7FCrBhI9I3M=
 golang.org/x/oauth2 v0.27.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8=
@@ -608,8 +676,8 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
-golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -631,6 +699,7 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -650,8 +719,8 @@ golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
 golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
 golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
 golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
-golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y=
-golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g=
+golang.org/x/term v0.33.0 h1:NuFncQrRcaRvVmgRkvM3j/F00gWIAlcmlB8ACEKmGIg=
+golang.org/x/term v0.33.0/go.mod h1:s18+ql9tYWp1IfpV9DmCtQDDSRBUjKaw9M1eAv5UeF0=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20181227161524-e6919f6577db/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
@@ -663,8 +732,8 @@ golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
-golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
+golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4=
+golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.9.0 h1:EsRrnYcQiGH+5FfbgvV4AP7qEZstoyrHB0DzarOQ4ZY=
 golang.org/x/time v0.9.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
@@ -674,12 +743,14 @@ golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20210105210202-9ed45478a130/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/tools v0.29.0 h1:Xx0h3TtM9rzQpQuR4dKLrdglAmCEN5Oi+P74JdhdzXE=
-golang.org/x/tools v0.29.0/go.mod h1:KMQVMRsVxU6nHCFXrBPhDB8XncLNLM0lIy/F14RP588=
+golang.org/x/tools v0.34.0 h1:qIpSLOxeCYGg9TrcJokLBG4KFA6d795g0xkBkiESGlo=
+golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -736,6 +807,7 @@ gopkg.in/square/go-jose.v2 v2.3.1/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v2 v2.0.0-20170712054546-1be3d31502d6/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/nitro-testnode b/nitro-testnode
index 88aa1f4ee31..48a0ed12a13 160000
--- a/nitro-testnode
+++ b/nitro-testnode
@@ -1 +1 @@
-Subproject commit 88aa1f4ee31182011195ec99992b5ff4d2e2c24d
+Subproject commit 48a0ed12a13667bf138961ad68098d177e24255c
diff --git a/pkgconfig/libnsm.pc b/pkgconfig/libnsm.pc
new file mode 100644
index 00000000000..4596b1edeab
--- /dev/null
+++ b/pkgconfig/libnsm.pc
@@ -0,0 +1,6 @@
+libdir=/path/to/lib
+
+Name: libnsm
+Description: Nitro Secure Module API
+Version: v0.4.0
+Libs: -L${libdir} -lnsm
\ No newline at end of file
diff --git a/release-please-config.json b/release-please-config.json
new file mode 100644
index 00000000000..80c452f907e
--- /dev/null
+++ b/release-please-config.json
@@ -0,0 +1,84 @@
+{
+  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
+  "release-type": "simple",
+  "tag-separator": "-espresso-",
+  "include-v-in-tag": true,
+  "bump-minor-pre-major": true,
+  "bump-patch-for-minor-pre-major": true,
+  "draft": false,
+  "prerelease": false,
+  "packages": {
+    ".": {
+      "component": "v3.9.8",
+      "bootstrap-sha": "249a3572d349d144e70e1226523f6c76622f76de",
+      "changelog-path": "CHANGELOG.md",
+      "release-type": "simple",
+      "extra-files": [
+        {
+          "type": "json",
+          "path": "version.json",
+          "jsonpath": "$.espresso"
+        }
+      ]
+    }
+  },
+  "changelog-sections": [
+    {
+      "type": "feat",
+      "section": "Features",
+      "hidden": false
+    },
+    {
+      "type": "fix",
+      "section": "Bug Fixes",
+      "hidden": false
+    },
+    {
+      "type": "perf",
+      "section": "Performance Improvements",
+      "hidden": false
+    },
+    {
+      "type": "revert",
+      "section": "Reverts",
+      "hidden": false
+    },
+    {
+      "type": "docs",
+      "section": "Documentation",
+      "hidden": false
+    },
+    {
+      "type": "chore",
+      "section": "Miscellaneous",
+      "hidden": true
+    },
+    {
+      "type": "style",
+      "section": "Styles",
+      "hidden": true
+    },
+    {
+      "type": "refactor",
+      "section": "Code Refactoring",
+      "hidden": true
+    },
+    {
+      "type": "test",
+      "section": "Tests",
+      "hidden": true
+    },
+    {
+      "type": "build",
+      "section": "Build System",
+      "hidden": true
+    },
+    {
+      "type": "ci",
+      "section": "CI/CD",
+      "hidden": true
+    }
+  ],
+  "pull-request-title-pattern": "chore(release): v${version}",
+  "pull-request-header": ":robot: This PR was automatically generated by release-please.\n\n**Before merging**, you can edit this PR to add more details to the changelog entries."
+}
diff --git a/scripts/caff-node-tester.sh b/scripts/caff-node-tester.sh
new file mode 100755
index 00000000000..f28a3c6b591
--- /dev/null
+++ b/scripts/caff-node-tester.sh
@@ -0,0 +1,59 @@
+#!/bin/bash
+
+sequencer_url=""
+caff_node_url=""
+address=""
+time_interval=10
+allow_delay_times=10
+
+while [[ "$#" -gt 0 ]]; do
+    case $1 in
+        --sequencer) sequencer_url="$2"; shift ;;
+        --caff-node) caff_node_url="$2"; shift ;;
+        --address) address="$2"; shift ;;
+        --interval) time_interval="$2"; shift ;;
+        --allow-delay) allow_delay_times="$2"; shift ;;
+        *) echo "Unknown parameter passed: $1"; exit 1 ;;
+    esac
+    shift
+done
+
+if [ -z "$sequencer_url" ]; then
+    echo "--sequencer is required"
+    exit 1
+fi
+
+if [ -z "$caff_node_url" ]; then
+    echo "--caff-node is required"
+    exit 1
+fi
+
+if [ -z "$address" ]; then
+    echo "--address is required"
+    exit 1
+fi
+
+delay_count=0
+
+while true; do
+    current_time=$(date +"%Y-%m-%d %H:%M:%S")
+    sequencer_balance=$(cast balance $address --rpc-url $sequencer_url)
+    echo "[$current_time] sequencer_balance: $sequencer_balance"
+
+    caff_node_balance=$(cast balance $address --rpc-url $caff_node_url)
+    echo "[$current_time] caff_node_balance: $caff_node_balance"
+
+    if [ "$sequencer_balance" != "$caff_node_balance" ]; then
+        delay_count=$((delay_count + 1))
+        echo "Warning: Balances do not match! Delay count: $delay_count"
+
+        if [ "$delay_count" -gt "$allow_delay_times" ]; then
+            echo "Error: Allowable delay times exceeded!"
+            exit 1
+        fi
+    else
+        delay_count=0
+    fi
+
+    sleep $time_interval
+done
diff --git a/scripts/espresso-ci-local b/scripts/espresso-ci-local
new file mode 100755
index 00000000000..00b5ae2ef57
--- /dev/null
+++ b/scripts/espresso-ci-local
@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Print failing command on exit
+trap 'echo "ERROR: $BASH_SOURCE:$LINENO $BASH_COMMAND" >&2' ERR
+
+make all
+make test-go-deps
+echo "Build passed"
+
+# make lint
+# echo "Lint passed"
+
+echo run tests without race detection
+scripts/espresso-run-test-ci
+env TEST_STATE_SCHEME=hash scripts/espresso-run-test-ci
+echo "Go tests passed"
+
+echo run tests with race detection
+scripts/espresso-run-test-ci -race
+env TEST_STATE_SCHEME=hash scripts/espresso-run-test-ci -race
+echo "Race tests passed"
+
+container=$(docker run -d -p 6379:6379 redis)
+trap "exit" INT TERM
+trap 'docker rm -f $container' EXIT
+echo run redis tests
+scripts/espresso-run-test-ci -run TestRedis ./arbnode/... ./system_tests/...
+echo "Redis tests passed"
+
+echo run challenge tests
+scripts/espresso-run-test-ci -run=TestChallenge -tags=challengetest
+echo "Go challenge tests passed"
+
+echo run stylus tests
+scripts/espresso-run-test-ci -tags=stylustest -run=TestProgramArbitrator
+scripts/espresso-run-test-ci -tags=stylustest -run=TestProgramLong
+echo "Stylus tests passed"
+
+echo "All tests passed"
diff --git a/scripts/fetch-pr-team-comments b/scripts/fetch-pr-team-comments
new file mode 100755
index 00000000000..be52aad75a8
--- /dev/null
+++ b/scripts/fetch-pr-team-comments
@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Security Model
+# ──────────────
+# This script pre-fetches PR review comments for use by AI code reviewers
+# (Claude, etc.). Only comments from team members (MEMBER, OWNER,
+# COLLABORATOR) and trusted bots (claude, gemini-code-assist)
+# are included.
+#
+# This mitigates prompt injection: external contributors' comments are
+# excluded. Team members are trusted because they already have the same
+# GitHub permissions as the AI reviewer.
+#
+# The AI reviewer reads the saved file instead of fetching comments
+# directly, so it cannot access excluded comments.
+#
+# Claude is not used for PR approval, only review, limiting the blast
+# radius of any injection.
+
+readonly SCRIPT_NAME="${0##*/}"
+
+usage() {
+  cat <<EOF
+Usage: ${SCRIPT_NAME} <org> <repo> <pr-number>
+
+Fetch PR review thread comments from team members and trusted bots.
+JSON is written to stdout, log messages to stderr.
+EOF
+}
+
+err() {
+  echo "${SCRIPT_NAME}: $*" >&2
+}
+
+main() {
+  case "${1-}" in
+    -h | --help)
+      usage
+      exit 0
+      ;;
+  esac
+
+  if [[ $# -ne 3 ]]; then
+    err "expected 3 arguments, got $#"
+    usage >&2
+    exit 1
+  fi
+
+  local org="$1"
+  local repo="$2"
+  local pr="$3"
+
+  local raw
+  raw="$(gh api graphql \
+    -F owner="$org" \
+    -F repo="$repo" \
+    -F pr="$pr" \
+    -f query='
+query($owner: String!, $repo: String!, $pr: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      comments(first: 100) {
+        pageInfo { hasNextPage }
+        nodes {
+          author { login }
+          authorAssociation
+          body
+        }
+      }
+      reviewThreads(first: 100) {
+        pageInfo { hasNextPage }
+        nodes {
+          id isResolved path line
+          comments(first: 100) {
+            nodes {
+              author { login }
+              authorAssociation
+              body
+            }
+          }
+        }
+      }
+    }
+  }
+}')"
+
+  local pr_data
+  pr_data="$(echo "${raw}" | jq '.data.repository.pullRequest')"
+
+  if echo "${pr_data}" | jq -e '.comments.pageInfo.hasNextPage or .reviewThreads.pageInfo.hasNextPage' > /dev/null; then
+    err "WARNING: results truncated at 100 items, some comments may be missing"
+  fi
+
+  local result
+  result="$(echo "${pr_data}" | jq '
+    def trusted:
+      (.authorAssociation | IN("MEMBER","OWNER","COLLABORATOR"))
+      or (.author.login | IN("claude","gemini-code-assist"));
+    {
+      comments: [.comments.nodes[] | select(trusted)],
+      reviewThreads: [.reviewThreads.nodes[]
+        | .comments.nodes |= [.[] | select(trusted)]
+        | select(.comments.nodes | length > 0)],
+      stats: {
+        all_comments: (.comments.nodes | length),
+        all_threads: (.reviewThreads.nodes | length)
+      }
+    }
+    | .stats as $s
+    | del(.stats)
+    | . + {_stats: {
+        comments: "\(.comments | length)/\($s.all_comments)",
+        threads: "\(.reviewThreads | length)/\($s.all_threads)"
+      }}
+  ')"
+
+  local stats
+  stats="$(echo "${result}" | jq -r '._stats | "\(.comments) PR comments + \(.threads) review threads"')"
+  err "Fetched ${stats} (filtered untrusted)"
+
+  echo "${result}" | jq 'del(._stats)'
+}
+
+main "$@"
diff --git a/scripts/run-espresso-batch-poster-ci-tests b/scripts/run-espresso-batch-poster-ci-tests
new file mode 100755
index 00000000000..574e5722130
--- /dev/null
+++ b/scripts/run-espresso-batch-poster-ci-tests
@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+# This script runs the Espresso tests in ./system_tests only.
+set -euo pipefail
+
+gotestsum \
+    --format short-verbose \
+    --packages="./..." \
+    --rerun-fails=1 \
+    -- \
+    -v \
+    -timeout 45m \
+    -p 1 \
+    -parallel 1 \
+    -run 'TestEspresso' \
+    -skip 'TestEspressoCaffNode|TestAuthDB|TestEspressoRegressionTransactionStreamerToEspressoThroughput'
diff --git a/scripts/run-espresso-caff-node-ci-tests b/scripts/run-espresso-caff-node-ci-tests
new file mode 100644
index 00000000000..7682fb1fb66
--- /dev/null
+++ b/scripts/run-espresso-caff-node-ci-tests
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# This script runs the Espresso tests in ./system_tests only.
+set -euo pipefail
+
+gotestsum \
+    --format short-verbose \
+    --packages="github.com/offchainlabs/nitro/espresso/authdb" \
+    -- \
+    -v \
+    -timeout 5m \
+    -p 1 \
+    ./espresso/authdb... \
+    -run 'TestAuthDB'
+
+gotestsum \
+    --format short-verbose \
+    --packages="github.com/offchainlabs/nitro/system_tests" \
+    -- \
+    -v \
+    -timeout 45m \
+    -p 1 \
+    -parallel 1 \
+    ./system_tests/... \
+    -run 'TestEspressoCaffNode'
diff --git a/scripts/run-transaction-streamer-regression-ci-tests b/scripts/run-transaction-streamer-regression-ci-tests
new file mode 100755
index 00000000000..9175146684b
--- /dev/null
+++ b/scripts/run-transaction-streamer-regression-ci-tests
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# This script runs the Espresso tests in ./system_tests only.
+set -euo pipefail
+
+gotestsum \
+    --format short-verbose \
+    --packages="github.com/offchainlabs/nitro/system_tests" \
+    -- \
+    -v \
+    -timeout 45m \
+    -p 1 \
+    ./system_tests/... \
+    -run 'TestEspressoRegressionTransactionStreamerToEspressoThroughput'
diff --git a/shell.nix b/shell.nix
new file mode 100644
index 00000000000..9eb132a589d
--- /dev/null
+++ b/shell.nix
@@ -0,0 +1,13 @@
+(import
+  (
+    let
+      lock = builtins.fromJSON (builtins.readFile ./flake.lock);
+    in
+    fetchTarball {
+      url = "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz";
+      sha256 = lock.nodes.flake-compat.locked.narHash;
+    }
+  )
+  {
+    src = ./.;
+  }).shellNix
diff --git a/solgen/gen.go b/solgen/gen.go
index e46d195b449..744cf12f712 100644
--- a/solgen/gen.go
+++ b/solgen/gen.go
@@ -132,6 +132,11 @@ func main() {
 		modInfo.addArtifact(artifact)
 	}
 
+	modules, err = GenerateEspressoTEEContracts(modules, parent)
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	yulFilePaths, err := filepath.Glob(filepath.Join(parent, "contracts", "out", "*", "*.yul", "*.json"))
 	if err != nil {
 		log.Fatal(err)
@@ -314,3 +319,36 @@ func main() {
 		fmt.Println("successfully exported abi files")
 	}
 }
+
+func GenerateEspressoTEEContracts(modules map[string]*moduleInfo, parent string) (map[string]*moduleInfo, error) {
+	filePathsEspressoTeeContracts, err := filepath.Glob(filepath.Join(parent, "espresso-tee-contracts", "out", "*.sol", "*.json"))
+	if err != nil {
+		return modules, fmt.Errorf("failed to get path for espresso tee contracts: %w", err)
+	}
+
+	espressoTEEContractsInfo := modules["espressogen"]
+	if espressoTEEContractsInfo == nil {
+		espressoTEEContractsInfo = &moduleInfo{}
+		modules["espressogen"] = espressoTEEContractsInfo
+	}
+
+	for _, path := range filePathsEspressoTeeContracts {
+		_, file := filepath.Split(path)
+		name := file[:len(file)-5]
+
+		data, err := os.ReadFile(path)
+		if err != nil {
+			return modules, fmt.Errorf("could not read %s for contract %s: %w", path, name, err)
+		}
+		artifact := FoundryArtifact{}
+		if err := json.Unmarshal(data, &artifact); err != nil {
+			return modules, fmt.Errorf("failed to parse espresso contract %s: %w", name, err)
+		}
+		espressoTEEContractsInfo.addArtifact(HardHatArtifact{
+			ContractName: name,
+			Abi:          artifact.Abi,
+			Bytecode:     artifact.Bytecode.Object,
+		})
+	}
+	return modules, nil
+}
diff --git a/system_tests/batch_poster_test.go b/system_tests/batch_poster_test.go
index b02e92dde9e..b802a2fc906 100644
--- a/system_tests/batch_poster_test.go
+++ b/system_tests/batch_poster_test.go
@@ -147,6 +147,8 @@ func testBatchPosterParallel(t *testing.T, useRedis bool, useRedisLock bool) {
 	for i := 0; i < parallelBatchPosters; i++ {
 		// Make a copy of the batch poster config so NewBatchPoster calling Validate() on it doesn't race
 		batchPosterConfig := builder.nodeConfig.BatchPoster
+		espressoConfig := builder.nodeConfig.Espresso
+
 		batchPoster, err := arbnode.NewBatchPoster(ctx,
 			&arbnode.BatchPosterOpts{
 				DataPosterDB:  nil,
@@ -160,6 +162,9 @@ func testBatchPosterParallel(t *testing.T, useRedis bool, useRedisLock bool) {
 				TransactOpts:  &seqTxOpts,
 				DAPWriter:     nil,
 				ParentChainID: parentChainID,
+				FatalErrChan:  make(chan error),
+
+				EspressoConfigFetcher: func() *arbnode.EspressoConfig { return &espressoConfig },
 			},
 		)
 		Require(t, err)
@@ -287,6 +292,8 @@ func TestRedisBatchPosterHandoff(t *testing.T) {
 	newBatchPoster := func() *arbnode.BatchPoster {
 		// Make a copy of the batch poster config so NewBatchPoster calling Validate() on it doesn't race
 		batchPosterConfig := builder.nodeConfig.BatchPoster
+		espressoConfig := builder.nodeConfig.Espresso
+
 		batchPoster, err := arbnode.NewBatchPoster(ctx,
 			&arbnode.BatchPosterOpts{
 				DataPosterDB:  nil,
@@ -300,6 +307,9 @@ func TestRedisBatchPosterHandoff(t *testing.T) {
 				TransactOpts:  &seqTxOpts,
 				DAPWriter:     nil,
 				ParentChainID: parentChainID,
+				FatalErrChan:  make(chan error),
+
+				EspressoConfigFetcher: func() *arbnode.EspressoConfig { return &espressoConfig },
 			},
 		)
 		Require(t, err)
@@ -452,7 +462,7 @@ func testAllowPostingFirstBatchWhenSequencerMessageCountMismatch(t *testing.T, e
 	seqInbox, err := bridgegen.NewSequencerInbox(builder.L1Info.GetAddress("SequencerInbox"), builder.L1.Client)
 	Require(t, err)
 	seqOpts := builder.L1Info.GetDefaultTransactOpts("Sequencer", ctx)
-	tx, err := seqInbox.AddSequencerL2Batch(&seqOpts, big.NewInt(1), nil, big.NewInt(1), common.Address{}, big.NewInt(1), big.NewInt(10))
+	tx, err := seqInbox.AddSequencerL2Batch99020501(&seqOpts, big.NewInt(1), nil, big.NewInt(1), common.Address{}, big.NewInt(1), big.NewInt(10), createDummyEspressoMetadata(t))
 	Require(t, err)
 	_, err = builder.L1.EnsureTxSucceeded(tx)
 	Require(t, err)
diff --git a/system_tests/bold_challenge_protocol_test.go b/system_tests/bold_challenge_protocol_test.go
index cfe93d4585b..9eeae67248a 100644
--- a/system_tests/bold_challenge_protocol_test.go
+++ b/system_tests/bold_challenge_protocol_test.go
@@ -637,7 +637,7 @@ func createTestNodeOnL1ForBoldProtocol(
 	execConfig := ExecConfigDefaultNonSequencerTest(t, rawdb.HashScheme)
 	Require(t, execConfig.Validate())
 	initMessage := getInitMessage(ctx, t, l1client, addresses)
-	_, l2stack, l2chainDb, l2arbDb, l2blockchain = createNonL1BlockChainWithStackConfig(t, l2info, "", chainConfig, nil, initMessage, nil, execConfig)
+	_, l2stack, l2chainDb, l2arbDb, l2blockchain = createNonL1BlockChainWithStackConfig(t, l2info, "", chainConfig, nil, initMessage, nil, execConfig, nil)
 	var sequencerTxOptsPtr *bind.TransactOpts
 	var dataSigner signature.DataSignerFunc
 	if isSequencer {
@@ -661,10 +661,11 @@ func createTestNodeOnL1ForBoldProtocol(
 	locator, err := server_common.NewMachineLocator("")
 	Require(t, err)
 	currentNode, err = arbnode.CreateNodeFullExecutionClient(
-		ctx, l2stack, execNode, execNode, execNode, execNode, l2arbDb, NewCommonConfigFetcher(nodeConfig), l2blockchain.Config(), l1client,
+		ctx, l2stack, execNode, execNode, execNode, execNode, l2arbDb, nil, NewCommonConfigFetcher(nodeConfig), l2blockchain.Config(), l1client,
 		addresses, sequencerTxOptsPtr, sequencerTxOptsPtr, dataSigner, fatalErrChan, parentChainId,
 		nil, // Blob reader.
 		locator.LatestWasmModuleRoot(),
+		nil,
 	)
 	Require(t, err)
 
@@ -738,6 +739,7 @@ func deployContractsOnly(
 		genesisExecutionState,
 		genesisInboxCount,
 		anyTrustFastConfirmer,
+		common.Address{},
 		challenge_testing.WithLayerZeroHeights(&protocol.LayerZeroHeights{
 			BlockChallengeHeight:     protocol.Height(blockChallengeLeafHeight),
 			BigStepChallengeHeight:   protocol.Height(bigStepChallengeLeafHeight),
@@ -877,7 +879,7 @@ func create2ndNodeWithConfigForBoldProtocol(
 	Require(t, err)
 	locator, err := server_common.NewMachineLocator("")
 	Require(t, err)
-	l2node, err := arbnode.CreateNodeFullExecutionClient(ctx, l2stack, execNode, execNode, execNode, execNode, l2arbDb, NewCommonConfigFetcher(nodeConfig), l2blockchain.Config(), l1client, addresses, &txOpts, &txOpts, dataSigner, fatalErrChan, l1ChainId, nil /* blob reader */, locator.LatestWasmModuleRoot())
+	l2node, err := arbnode.CreateNodeFullExecutionClient(ctx, l2stack, execNode, execNode, execNode, execNode, l2arbDb, nil, NewCommonConfigFetcher(nodeConfig), l2blockchain.Config(), l1client, addresses, &txOpts, &txOpts, dataSigner, fatalErrChan, l1ChainId, nil /* blob reader */, locator.LatestWasmModuleRoot(), nil)
 	Require(t, err)
 
 	l2client := ClientForStack(t, l2stack)
@@ -940,7 +942,7 @@ func makeBoldBatch(
 
 	seqNum := new(big.Int).Lsh(common.Big1, 256)
 	seqNum.Sub(seqNum, common.Big1)
-	tx, err := seqInbox.AddSequencerL2BatchFromOrigin8f111f3c(sequencer, seqNum, message, big.NewInt(1), common.Address{}, big.NewInt(0), big.NewInt(0))
+	tx, err := seqInbox.AddSequencerL2BatchFromOrigin37501551(sequencer, seqNum, message, big.NewInt(1), common.Address{}, big.NewInt(0), big.NewInt(0), createDummyEspressoMetadata(t))
 	Require(t, err)
 	receipt, err := EnsureTxSucceeded(ctx, backend, tx)
 	Require(t, err)
diff --git a/system_tests/caff_node_test.go b/system_tests/caff_node_test.go
new file mode 100644
index 00000000000..07a5413bc27
--- /dev/null
+++ b/system_tests/caff_node_test.go
@@ -0,0 +1,854 @@
+package arbtest
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math"
+	"math/big"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/mock"
+
+	"github.com/ethereum/go-ethereum"
+	"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/log"
+	"github.com/ethereum/go-ethereum/rpc"
+
+	"github.com/offchainlabs/nitro/arbnode"
+	"github.com/offchainlabs/nitro/arbnode/dataposter"
+	"github.com/offchainlabs/nitro/espressostreamer"
+	"github.com/offchainlabs/nitro/espressotee"
+	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
+	"github.com/offchainlabs/nitro/util/testhelpers"
+)
+
+func createCaffNode(
+	ctx context.Context,
+	t *testing.T,
+	existing *NodeBuilder,
+	dangerous bool,
+) (*NodeBuilder, func(), error) {
+	builder := NewNodeBuilder(ctx).DefaultConfig(t, false).DontParalellise()
+	nodeConfig := builder.nodeConfig
+	execConfig := builder.execConfig
+
+	// Disable the transaction indexer
+	execConfig.TxIndexer.Enable = false
+
+	// Disable the batch poster because it requires redis if enabled on the 2nd node
+	nodeConfig.BatchPoster.Enable = false
+	nodeConfig.BlockValidator.Enable = false
+	nodeConfig.DelayedSequencer.Enable = false
+	nodeConfig.DelayedSequencer.FinalizeDistance = 1
+	nodeConfig.Sequencer = false
+	nodeConfig.Dangerous.NoSequencerCoordinator = true
+	execConfig.Sequencer.Enable = false
+	execConfig.ForwardingTarget = existing.l2StackConfig.IPCPath
+	execConfig.SecondaryForwardingTarget = []string{}
+	nodeConfig.Espresso.CaffNode.Enable = true
+	nodeConfig.Espresso.CaffNode.Namespace = builder.chainConfig.ChainID.Uint64()
+	nodeConfig.Espresso.Streamer.HotShotBlock = 1
+	nodeConfig.Espresso.CaffNode.SGXVerifierAddr = existing.L1Info.GetAddress("EspressoTEEVerifierMock").Hex()
+
+	// reuse the caff node settings so we can set them outside this function.
+	nodeConfig.Espresso.CaffNode.WaitForFinalization = existing.nodeConfig.Espresso.CaffNode.WaitForFinalization
+	nodeConfig.Espresso.CaffNode.RequiredBlockDepth = existing.nodeConfig.Espresso.CaffNode.RequiredBlockDepth
+	nodeConfig.Espresso.CaffNode.BatchPosterAddr = "0xb386a74Dcab67b66F8AC07B4f08365d37495Dd23"
+	nodeConfig.Espresso.Streamer.AddressMonitorStartL1 = 1
+	nodeConfig.Espresso.CaffNode.TeeType = ""
+	nodeConfig.Espresso.CaffNode.DataPoster = dataposter.DefaultDataPosterConfig
+
+	nodeConfig.Espresso.CaffNode.StateChecker = arbnode.StateCheckerConfig{
+		PollingInterval:        time.Second * 100,
+		ErrorToleranceDuration: time.Hour * 1, // Set it to a larger value. That makes the state checker not shut down
+		TrustedNodeUrl:         fmt.Sprintf("http://bad-url:%d", 8945),
+	}
+
+	nodeConfig.Espresso.CaffNode.ForceInclusionChecker = arbnode.ForceInclusionCheckerConfig{
+		RetryTime:                time.Second * 2,
+		PollingInterval:          time.Second * 1,
+		BlockThresholdTolerance:  20,
+		SecondThresholdTolerance: 200,
+		ErrorToleranceDuration:   time.Minute * 10,
+	}
+
+	// for testing, we can use the same hotshot url for both
+	nodeConfig.Espresso.CaffNode.HotShotUrl = hotShotUrl
+	nodeConfig.Espresso.Streamer.TxnsPollingInterval = time.Second * 1
+	nodeConfig.Espresso.CaffNode.HotshotPollingInterval = time.Millisecond * 100
+	nodeConfig.ParentChainReader.Enable = true
+
+	builder.l2StackConfig.HTTPPort = getRandomPort(t)
+	builder.l2StackConfig.HTTPHost = "0.0.0.0"
+
+	if dangerous {
+		nodeConfig.Espresso.CaffNode.Dangerous.IgnoreDatabaseHotshotBlock = true
+		nodeConfig.Espresso.Streamer.HotShotBlock = 0
+	}
+
+	nodeConfig.Espresso.CaffNode.TeeType = existing.nodeConfig.Espresso.CaffNode.TeeType
+	nodeConfig.Espresso.CaffNode.SnapshotChecksum = existing.nodeConfig.Espresso.CaffNode.SnapshotChecksum
+	nodeConfig.Espresso.CaffNode.GenerateSnapshot = existing.nodeConfig.Espresso.CaffNode.GenerateSnapshot
+	nodeConfig.Espresso.CaffNode.TEEVerifierAddr = existing.nodeConfig.Espresso.CaffNode.TEEVerifierAddr
+
+	cleanup, err := builder.BuildEspressoCaffNode(t, existing)
+	builder.L1 = existing.L1
+	return builder, cleanup, err
+}
+
+func createCaffNodeConfig(ctx context.Context, t *testing.T) *NodeBuilder {
+	builder := NewNodeBuilder(ctx).DefaultConfig(t, true)
+	nodeConfig := builder.nodeConfig
+	execConfig := builder.execConfig
+
+	// Disable the batch poster because it requires redis if enabled on the 2nd node
+	nodeConfig.BatchPoster.Enable = false
+	nodeConfig.BlockValidator.Enable = false
+	nodeConfig.DelayedSequencer.Enable = false
+	nodeConfig.DelayedSequencer.FinalizeDistance = 1
+	nodeConfig.Sequencer = false
+	nodeConfig.Dangerous.NoSequencerCoordinator = true
+	execConfig.Sequencer.Enable = false
+	execConfig.SecondaryForwardingTarget = []string{}
+	nodeConfig.Espresso.CaffNode.Enable = true
+	nodeConfig.Espresso.CaffNode.Namespace = builder.chainConfig.ChainID.Uint64()
+	nodeConfig.Espresso.Streamer.HotShotBlock = 1
+	nodeConfig.Espresso.CaffNode.BatchPosterAddr = "0xb386a74Dcab67b66F8AC07B4f08365d37495Dd23"
+
+	// for testing, we can use the same hotshot url for both
+	nodeConfig.Espresso.CaffNode.HotShotUrl = hotShotUrl
+	nodeConfig.Espresso.Streamer.TxnsPollingInterval = time.Second * 1
+	nodeConfig.Espresso.CaffNode.HotshotPollingInterval = time.Millisecond * 100
+	nodeConfig.Espresso.Streamer.AddressMonitorStartL1 = 1
+	nodeConfig.ParentChainReader.Enable = true
+
+	return builder
+}
+
+// assertEventOrderingHelper is a simple helper fuction that assists in converting the errors presented by the event functions to booleans and passing them back over the channel
+func assertEventOrderingHelper(channel chan bool, eventFunc func() error) {
+	err := eventFunc()
+	if err != nil {
+		channel <- false
+	} else {
+		channel <- true
+	}
+}
+
+// AssertEventOrdering:
+// This function is responsible for asserting that 2 concurrent events happen in a specific order.
+//
+// Semantics:
+// This function will assert that each event can happen only once and will either succeed or fail.
+// The only way this function does not fail is if both events succeed in the correct order.
+// This would be relatively easy to change to asserting that the second event can fail before the first event succeeds.
+//
+// Parameters:
+// firstEventFunc: A function that can be executed as a goroutine and has an error condition that can be mapped to success vs failure. This should capture the event that should happen first
+// secondEventFunc: A function that can be executed as a goroutine and has an error condition that can be mapped to success vs failure. This should capture the event that should happen second
+func AssertEventOrdering(t *testing.T, firstEventFunc func() error, secondEventFunc func() error) {
+	var firstEventSuccess bool
+	var eventOrderSuccess bool
+	firstEvent := make(chan bool)
+	secondEvent := make(chan bool)
+	go assertEventOrderingHelper(firstEvent, firstEventFunc)
+	go assertEventOrderingHelper(secondEvent, secondEventFunc)
+	for {
+		select {
+		case success := <-firstEvent:
+			if success {
+				firstEventSuccess = true
+			} else {
+				t.Fatal("First event in ordered assert did not succeed")
+			}
+		case success := <-secondEvent:
+			if !success {
+				t.Fatal("Second event in ordered assert did not succeed")
+			}
+			if !firstEventSuccess {
+				t.Fatal("Events occurred in an incorrect order according to the assertion")
+			} else {
+				eventOrderSuccess = true
+				break
+			}
+
+		}
+		if eventOrderSuccess {
+			break
+		}
+	}
+}
+
+func TestEspressoCaffNode(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	valNodeCleanup := createValidationNode(ctx, t, true)
+	defer valNodeCleanup()
+
+	builder, cleanup := createL1AndL2Node(ctx, t, true, false)
+	defer cleanup()
+
+	err := waitForL1Node(ctx)
+	Require(t, err)
+
+	cleanEspresso := runEspresso()
+	defer cleanEspresso()
+	// wait for the builder
+	err = waitForEspressoNode(ctx)
+	Require(t, err)
+
+	err = checkTransferTxOnL2(t, ctx, builder.L2, "User14", builder.L2Info)
+	Require(t, err)
+	err = checkTransferTxOnL2(t, ctx, builder.L2, "User15", builder.L2Info)
+	Require(t, err)
+
+	newAccount := "User16"
+	l2Info := builder.L2Info
+	l2Info.GenerateAccount(newAccount)
+	addr := l2Info.GetAddress(newAccount)
+
+	// Transfer via the delayed inbox
+	delayedTx := l2Info.PrepareTx("Owner", newAccount, 3e7, transferAmount, nil)
+	builder.L1.SendWaitTestTransactions(t, []*types.Transaction{
+		WrapL2ForDelayed(t, delayedTx, builder.L1Info, "Faucet", 100000),
+	})
+
+	err = waitForWith(ctx, 240*time.Second, 10*time.Second, func() bool {
+		AdvanceL1(t, ctx, builder.L1.Client, builder.L1Info, 100)
+		balance := builder.L2.GetBalance(t, addr)
+		log.Info("waiting for balance", "account", newAccount, "addr", addr, "balance", balance)
+		return balance.Cmp(transferAmount) >= 0
+	})
+	Require(t, err)
+
+	// don't make the caff node wait for finalization during the default test.
+	builder.nodeConfig.Espresso.CaffNode.WaitForFinalization = false
+	// start the node
+	builder, _, err = createCaffNode(ctx, t, builder, false)
+	Require(t, err)
+	builderCaffNode := builder.L2
+
+	err = waitForWith(ctx, 10*time.Minute, 10*time.Second, func() bool {
+		balance1 := builderCaffNode.GetBalance(t, l2Info.GetAddress("User14"))
+		balance2 := builderCaffNode.GetBalance(t, l2Info.GetAddress("User15"))
+		log.Info("waiting for balance", "account", "User14", "balance", balance1, "account", "User15", "balance", balance2)
+		return balance1.Cmp(transferAmount) > 0 && balance2.Cmp(transferAmount) > 0
+	})
+	Require(t, err)
+
+	err = waitForWith(ctx, 240*time.Second, 10*time.Second, func() bool {
+		balance := builderCaffNode.GetBalance(t, addr)
+		log.Info("waiting for balance", "account", newAccount, "addr", addr, "balance", balance)
+		if balance.Cmp(transferAmount) >= 0 {
+			log.Info("Balance has entered account", "balance", balance, "account", newAccount)
+		}
+		return balance.Cmp(transferAmount) >= 0
+	})
+	Require(t, err)
+
+	rpcClient := builderCaffNode.Client.Client()
+	startTime := time.Now()
+	// Wait till we have two blocks created
+	for {
+		var lastBlock map[string]interface{}
+		err = rpcClient.CallContext(ctx, &lastBlock, "eth_getBlockByNumber", "latest", false)
+		Require(t, err)
+		if lastBlock == nil {
+			// fail
+			t.Fatal("last block is nil")
+		}
+		log.Info("last block", "lastBlock", lastBlock)
+		numberString, ok := lastBlock["number"].(string)
+		if !ok {
+			t.Fatal("number is not a string")
+		}
+		// convert number to uint
+		number, err := strconv.ParseInt(numberString, 0, 64)
+		Require(t, err)
+		if number >= 3 {
+			break
+		}
+		if time.Since(startTime) > 10*time.Minute {
+			t.Fatal("timeout waiting for node to create blocks")
+		}
+		time.Sleep(time.Second * 5)
+	}
+
+	// Send transaction to CaffNode and it should works later
+	err = checkTransferTxOnL2(t, ctx, builderCaffNode, "User17", l2Info)
+	Require(t, err)
+
+	err = rpcClient.CallContext(ctx, nil, "eth_getBlockByNumber", "latest", false)
+	Require(t, err)
+
+	err = rpcClient.CallContext(ctx, nil, "eth_getBlockByNumber", "finalized", false)
+	Require(t, err)
+
+	err = rpcClient.CallContext(ctx, nil, "eth_getBlockByNumber", "safe", false)
+	Require(t, err)
+
+	// start the trusted node
+	trustedPort := 9000
+	trustedCleanup := mockTrustedNode(t, ctx, trustedPort)
+	defer trustedCleanup()
+
+	time.Sleep(10 * time.Second)
+
+	fatalErrChan := make(chan error)
+	// Check the state checker
+	port := builder.l2StackConfig.HTTPPort
+	// Set the trusted node url to the L1 node
+	// This is to simulate the trusted url returning a different block
+	stateChecker := arbnode.NewStateChecker(
+		arbnode.StateCheckerConfig{
+			PollingInterval:        time.Second * 1,
+			TrustedNodeUrl:         fmt.Sprintf("http://localhost:%d", trustedPort),
+			ErrorToleranceDuration: time.Second * 100,
+		},
+		port,
+		fatalErrChan,
+	)
+	// Start the monitoring task without initial checking
+	err = stateChecker.Start(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	select {
+	case err := <-fatalErrChan:
+		if err == nil {
+			t.Fatal("expected an error from fatalErrChan, got nil")
+		} else {
+			t.Logf("received error as expected: %v", err)
+		}
+	case <-time.After(30 * time.Second):
+		t.Fatal("did not receive error from fatalErrChan within timeout")
+	}
+}
+
+func mockTrustedNode(t *testing.T, ctx context.Context, port int) func() {
+	builder := NewNodeBuilder(ctx).DefaultConfig(t, false).DontParalellise()
+	builder.l2StackConfig.HTTPPort = port
+	builder.l2StackConfig.HTTPHost = "0.0.0.0"
+	return builder.BuildL2(t)
+}
+
+func Setup(t *testing.T) (context.Context, common.Address, info, string, context.CancelFunc, func(), *NodeBuilder, func(), func()) {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	valNodeCleanup := createValidationNode(ctx, t, true)
+
+	builder, cleanup := createL1AndL2Node(ctx, t, true, false)
+
+	err := waitForL1Node(ctx)
+	Require(t, err)
+
+	cleanEspresso := runEspresso()
+
+	// wait for the builder
+	err = waitForEspressoNode(ctx)
+	Require(t, err)
+
+	newAccount := "User16"
+	l2Info := builder.L2Info
+	l2Info.GenerateAccount(newAccount)
+	addr := l2Info.GetAddress(newAccount)
+	return ctx, addr, l2Info, newAccount, cancel, valNodeCleanup, builder, cleanup, cleanEspresso
+}
+
+func TestEspressoCaffNodeDelayedMessagesConfirmations(t *testing.T) {
+	ctx, addr, l2Info, newAccount, cancel, valNodeCleanup, builder, cleanup, cleanEspresso := Setup(t)
+	defer cancel()
+	defer valNodeCleanup()
+	defer cleanup()
+	defer cleanEspresso()
+
+	// Set caff node config variables
+	builder.nodeConfig.Espresso.CaffNode.RequiredBlockDepth = 6
+	builder.nodeConfig.Espresso.CaffNode.WaitForFinalization = false
+
+	// start the node
+	log.Info("Starting the caff node")
+	builder2, cleanupCaffNode, err := createCaffNode(ctx, t, builder, false)
+	Require(t, err)
+	builderCaffNode := builder2.L2
+	defer cleanupCaffNode()
+
+	// Transfer via the delayed inbox
+	delayedTx := l2Info.PrepareTx("Owner", newAccount, 3e7, transferAmount, nil)
+	log.Info("Delayed tx", "delayedtx", delayedTx)
+	tx := builder.L1.SendWaitTestTransactions(t, []*types.Transaction{
+		WrapL2ForDelayed(t, delayedTx, builder.L1Info, "Faucet", 100000),
+	})
+
+	// Check the caff node RPC for tx. assert that it is not there.
+	_, _, err = builderCaffNode.Client.TransactionByHash(ctx, tx[0].TxHash)
+	ExpectErr(t, err, ethereum.NotFound)
+	AdvanceL1(t, ctx, builder.L1.Client, builder.L1Info, 100)
+
+	// Create the event function closures for the assert statement.
+	firstEvent := func() error {
+		err := waitForWith(ctx, 240*time.Second, 1*time.Second, func() bool {
+			AdvanceL1(t, ctx, builder.L1.Client, builder.L1Info, 10)
+			header, err := builder.L1.Client.HeaderByNumber(ctx, nil) // get the latest header to check tx block depth
+			Require(t, err)
+			return header.Number.Uint64() >= tx[0].BlockNumber.Uint64()+builder.nodeConfig.Espresso.CaffNode.RequiredBlockDepth // check that the tx is at least RequiredBlockDepth blocks deep in the parent chains state.
+		})
+		return err
+	}
+	secondEvent := func() error {
+		err := waitForWith(ctx, 240*time.Second, 10*time.Second, func() bool {
+			balance := builderCaffNode.GetBalance(t, addr)
+			log.Info("waiting for balance", "account", newAccount, "addr", addr, "balance", balance)
+			if balance.Cmp(transferAmount) >= 0 {
+				log.Info("Balance has entered account", "balance", balance, "account", newAccount)
+			}
+			return balance.Cmp(transferAmount) >= 0
+		})
+		return err
+	}
+	// Assert that the delayed message should reach the required block depth before the balance appears on the caff node.
+	AssertEventOrdering(t, firstEvent, secondEvent)
+	log.Info("Concurrent events finished in the correct order!")
+}
+
+func TestEspressoCaffNodeDelayedMessagesFinalized(t *testing.T) {
+	ctx, addr, l2Info, newAccount, cancel, valNodeCleanup, builder, cleanup, cleanEspresso := Setup(t)
+	defer cancel()
+	defer valNodeCleanup()
+	defer cleanup()
+	defer cleanEspresso()
+
+	// Wait for l1 node
+	err := waitForL1Node(ctx)
+	Require(t, err)
+
+	// Set caff node config vars
+	builder.nodeConfig.Espresso.CaffNode.RequiredBlockDepth = 6
+	builder.nodeConfig.Espresso.CaffNode.WaitForFinalization = true
+	// start the node
+	log.Info("Starting the caff node")
+	builder2, cleanupCaffNode, err := createCaffNode(ctx, t, builder, false)
+	Require(t, err)
+	builderCaffNode := builder2.L2
+	defer cleanupCaffNode()
+
+	// Transfer via the delayed inbox
+	delayedTx := l2Info.PrepareTx("Owner", newAccount, 3e7, transferAmount, nil)
+	log.Info("Delayed tx", "delayedtx", delayedTx)
+	tx := builder.L1.SendWaitTestTransactions(t, []*types.Transaction{
+		WrapL2ForDelayed(t, delayedTx, builder.L1Info, "Faucet", 100000),
+	})
+	// Check the caff node RPC for tx. assert that it is not there.
+	_, _, err = builderCaffNode.Client.TransactionByHash(ctx, tx[0].TxHash)
+	ExpectErr(t, err, ethereum.NotFound)
+	// Wait for the tx header to be finalized.
+
+	firstEvent := func() error {
+		err := waitForWith(ctx, 240*time.Second, 1*time.Second, func() bool {
+			header, err := builder.L1.Client.HeaderByNumber(ctx, big.NewInt(rpc.FinalizedBlockNumber.Int64()))
+			Require(t, err)
+			AdvanceL1(t, ctx, builder.L1.Client, builder.L1Info, 30)
+			return header.Number.Int64() >= tx[0].BlockNumber.Int64()
+		})
+		return err
+	}
+	secondEvent := func() error {
+		err := waitForWith(ctx, 240*time.Second, 10*time.Second, func() bool {
+			balance := builderCaffNode.GetBalance(t, addr)
+			log.Info("waiting for balance", "account", newAccount, "addr", addr, "balance", balance)
+			if balance.Cmp(transferAmount) >= 0 {
+				log.Info("Balance has entered account", "balance", balance, "account", newAccount)
+			}
+			return balance.Cmp(transferAmount) >= 0
+		})
+		return err
+	}
+	AssertEventOrdering(t, firstEvent, secondEvent)
+	log.Info("Concurrent events finished in the correct order!")
+}
+
+func TestEspressoCaffNodeUnfinalizedDelayedMessages(t *testing.T) {
+	ctx, addr, l2Info, newAccount, cancel, valNodeCleanup, builder, cleanup, cleanEspresso := Setup(t)
+	defer cancel()
+	defer valNodeCleanup()
+	defer cleanup()
+	defer cleanEspresso()
+	// set caff node config vars
+	builder.nodeConfig.Espresso.CaffNode.RequiredBlockDepth = 0
+	builder.nodeConfig.Espresso.CaffNode.WaitForFinalization = false
+
+	// start the node
+	log.Info("Starting the caff node")
+	builder2, cleanupCaffNode, err := createCaffNode(ctx, t, builder, false)
+	Require(t, err)
+	builderCaffNode := builder2.L2
+	defer cleanupCaffNode()
+
+	// Transfer via the delayed inbox
+	delayedTx3 := l2Info.PrepareTx("Owner", newAccount, 3e7, transferAmount, nil)
+	tx3 := builder.L1.SendWaitTestTransactions(t, []*types.Transaction{
+		WrapL2ForDelayed(t, delayedTx3, builder.L1Info, "Faucet", 100000),
+	})
+	// Advance L1 to make sure the tx is included.
+	// Since the caff node is not waiting for finalization, it should appear after 1 block.
+	AdvanceL1(t, ctx, builder.L1.Client, builder.L1Info, 1)
+	// Wait for the tx to appear on the caff node
+	err = waitForWith(ctx, 240*time.Second, 10*time.Second, func() bool {
+		balance := builderCaffNode.GetBalance(t, addr)
+		log.Info("waiting for balance", "account", newAccount, "addr", addr, "balance", balance)
+		if balance.Cmp(transferAmount) >= 0 {
+			log.Info("Balance has entered account", "balance", balance, "account", newAccount)
+		}
+		return balance.Cmp(transferAmount) >= 0
+	})
+	Require(t, err)
+
+	finalizedHeader, err := builder.L1.Client.HeaderByNumber(ctx, big.NewInt(rpc.FinalizedBlockNumber.Int64()))
+	if tx3[0].BlockNumber.Int64() <= finalizedHeader.Number.Int64() {
+		t.Fatal("Tx finalized before appearing in the caff node")
+	}
+	Require(t, err)
+}
+
+func TestEspressoCaffNodeSnapshot(t *testing.T) {
+	// First we will run the caff node in generate snapshot mode
+	ctx, _, _, _, cancel, valNodeCleanup, builder, cleanup, cleanEspresso := Setup(t)
+	defer cancel()
+	defer valNodeCleanup()
+	defer cleanup()
+	defer cleanEspresso()
+
+	// Set caff node config variables
+	builder.nodeConfig.Espresso.CaffNode.RequiredBlockDepth = 6
+	builder.nodeConfig.Espresso.CaffNode.WaitForFinalization = false
+	builder.nodeConfig.Espresso.CaffNode.GenerateSnapshot = true
+
+	// start the node
+	log.Info("Starting the caff node initially")
+	// Start the caff node without a snapshot signer
+	builderCaffNode, cleanupCaffNode, err := createCaffNode(ctx, t, builder, false)
+	Require(t, err)
+
+	err = checkTransferTxOnL2(t, ctx, builder.L2, "User14", builder.L2Info)
+	Require(t, err)
+	err = checkTransferTxOnL2(t, ctx, builder.L2, "User15", builder.L2Info)
+	Require(t, err)
+
+	err = waitForWith(ctx, 10*time.Minute, 10*time.Second, func() bool {
+		balance1 := builderCaffNode.L2.GetBalance(t, builder.L2Info.GetAddress("User14"))
+		balance2 := builderCaffNode.L2.GetBalance(t, builder.L2Info.GetAddress("User15"))
+		log.Info("waiting for balance", "account", "User14", "balance", balance1, "account", "User15", "balance", balance2)
+		return balance1.Cmp(transferAmount) > 0 && balance2.Cmp(transferAmount) > 0
+	})
+	Require(t, err)
+
+	// start the node
+	time.Sleep(10 * time.Second)
+
+	cleanupCaffNode()
+
+	// Now we need to check if it created a snapshot.txt file in the parent chain directory
+	snapshotFile := filepath.Join(filepath.Join(builderCaffNode.dataDir, builderCaffNode.l2StackConfig.Name), "snapshot.txt")
+	// Read the snapshot file and get the sha256 hash
+	snapshotFileContent, err := os.ReadFile(snapshotFile)
+	Require(t, err)
+
+	// Convert to base64 to string
+	base64SnapshotFileContent := strings.TrimSpace(string(snapshotFileContent))
+	log.Info("sha256Hash read from snapshot.txt", "sha256Hash", base64SnapshotFileContent)
+
+	// now we need to restart the caff node in Snapshot mode such and it will use this snapshot,
+	// verify it and re-initialize the tags with tmac
+	builderCaffNode.nodeConfig.Espresso.CaffNode.SnapshotChecksum = base64SnapshotFileContent
+	builderCaffNode.nodeConfig.Espresso.CaffNode.TeeType = "TESTS"
+	builderCaffNode.nodeConfig.Espresso.CaffNode.GenerateSnapshot = false
+
+	parentChainTransactionOpts := builderCaffNode.L1Info.GetDefaultTransactOpts("RollupOwner", ctx)
+	espressoTEEVerifierAddress, _, _, err := deployMockTEEContracts(t, &parentChainTransactionOpts, builder.L1.Client)
+	Require(t, err)
+	builderCaffNode.nodeConfig.Espresso.CaffNode.TEEVerifierAddr = espressoTEEVerifierAddress.Hex()
+
+	logHandler := testhelpers.InitTestLog(t, log.LevelInfo)
+	_ = logHandler
+
+	time.Sleep(10 * time.Second)
+	builderCaffNode.RestartCaffNode(t)
+
+	// This time check if it printed the log about snapshot already verified
+	err = waitForWith(ctx, 10*time.Minute, 1*time.Second, func() bool {
+		return logHandler.WasLogged("Snapshot hash matches")
+	})
+	Require(t, err)
+
+	// Now restart the caff node again, and it should print that the snapshot has already been verified previously
+	builderCaffNode.L2.cleanup()
+
+	time.Sleep(10 * time.Second)
+	builderCaffNode.RestartCaffNode(t)
+
+	// This time check if it printed the log about snapshot already verified
+	err = waitForWith(ctx, 10*time.Minute, 1*time.Second, func() bool {
+		return logHandler.WasLogged("Snapshot has already been verified previously")
+	})
+
+	Require(t, err)
+}
+
+// RequireErr:
+// This serves to assert that we should be expecting some error during the test, and if there is not an error, fail the test.
+func RequireErr(t *testing.T, err error, expectedError error) {
+	t.Helper()
+	if err == nil {
+		log.Error("expected an error to occur", "expected error", expectedError)
+		t.Fatal(err, expectedError)
+	}
+}
+
+// ExpectErr:
+// This serves to assert that we should be expecting a specific error during the test, and if the error does not match, fail the test.
+func ExpectErr(t *testing.T, err error, expectedError error) {
+	t.Helper()
+	if !errors.Is(err, expectedError) {
+		t.Fatal(err, expectedError)
+	}
+}
+
+// This tests that the caff node config validates that known versions of arb sequencers are not enabled if the caff node is.
+func TestEspressoCaffNodeConfig(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	builder := createCaffNodeConfig(ctx, t)
+	err := builder.nodeConfig.Validate()
+	Require(t, err)
+
+	expectedErr := errors.New("cannot start a Caff node with any sequencer enabled")
+	// Test if this node is attempting to be a sequencer
+	builder.nodeConfig.Sequencer = true
+	err = builder.nodeConfig.Validate()
+	RequireErr(t, err, expectedErr)
+	// Test the delayed sequencer
+	builder.nodeConfig.Sequencer = false
+	builder.nodeConfig.DelayedSequencer.Enable = true
+
+	err = builder.nodeConfig.Validate()
+	RequireErr(t, err, expectedErr)
+
+	builder.nodeConfig.DelayedSequencer.Enable = false
+	builder.nodeConfig.SeqCoordinator.Enable = true
+
+	err = builder.nodeConfig.Validate()
+	RequireErr(t, err, expectedErr)
+
+}
+
+func TestEspressoCaffNodeDangerousConfig(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	builder, cleanup := createL1AndL2Node(ctx, t, true, false)
+	defer cleanup()
+
+	// start the node
+	_, cleanupCaffNode, err := createCaffNode(ctx, t, builder, true)
+	if cleanupCaffNode != nil {
+		defer cleanupCaffNode()
+	}
+
+	// The actual error is wrapped in an array, so we need to check for that
+	expectedErrMsg := "no next hotshot block found in database or dangerous.ignore-database-hotshot-block is set to true, please set config.CaffNodeConfig.NextHotshotBlock"
+
+	if err == nil {
+		t.Fatal("Expected an error but got nil")
+	}
+
+	// Check if the error contains the expected message (since it might be wrapped)
+	if !strings.Contains(err.Error(), expectedErrMsg) {
+		t.Errorf("Expected error to contain %q, got %q", expectedErrMsg, err.Error())
+	}
+}
+
+type mockSgxTeeVerifier struct {
+	mock.Mock
+
+	time time.Time
+}
+
+var _ espressotee.EspressoSGXVerifierInterface = (*mockSgxTeeVerifier)(nil)
+
+func (v *mockSgxTeeVerifier) Verify(opts *bind.CallOpts, attestation []byte, signature [32]byte) (espressotee.EnclaveReport, error) {
+	if time.Since(v.time) < 1*time.Minute {
+		return espressotee.EnclaveReport{}, rpc.HTTPError{StatusCode: 500, Status: "Internal Server Error", Body: []byte("Internal Server Error")}
+	}
+	return espressotee.EnclaveReport{}, nil
+}
+
+func NewMockSgxTeeVerifier() *mockSgxTeeVerifier {
+	return &mockSgxTeeVerifier{
+		time: time.Now(),
+	}
+}
+
+func TestEspressoCaffNodeSGXVerifierShouldRetryWhenEncounterRPCError(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	builder, cleanup := createL1AndL2Node(ctx, t, true, false)
+	defer cleanup()
+
+	cleanEspresso := runEspresso()
+	defer cleanEspresso()
+
+	// wait for the builder
+	err := waitForEspressoNode(ctx)
+	Require(t, err)
+
+	err = checkTransferTxOnL2(t, ctx, builder.L2, "User14", builder.L2Info)
+	Require(t, err)
+	err = checkTransferTxOnL2(t, ctx, builder.L2, "User15", builder.L2Info)
+	Require(t, err)
+
+	builder2, cleanupCaffNode, err := createCaffNode(ctx, t, builder, false)
+	defer cleanupCaffNode()
+	Require(t, err)
+
+	err = waitForWith(ctx, 10*time.Minute, 10*time.Second, func() bool {
+		balance1 := builder2.L2.GetBalance(t, builder.L2Info.GetAddress("User14"))
+		balance2 := builder2.L2.GetBalance(t, builder.L2Info.GetAddress("User15"))
+		log.Info("waiting for balance", "account", "User14", "balance", balance1, "account", "User15", "balance", balance2)
+		return balance1.Cmp(transferAmount) > 0 && balance2.Cmp(transferAmount) > 0
+	})
+	Require(t, err)
+
+	espressoStreamerInterface := builder2.L2.ConsensusNode.EspressoCaffNode.GetEspressoStreamer()
+	espressoStreamer, ok := espressoStreamerInterface.(*espressostreamer.EspressoStreamer)
+	if !ok {
+		t.Fatal("espresso streamer is not of type EspressoStreamer")
+	}
+
+	err = checkTransferTxOnL2(t, ctx, builder.L2, "User16", builder.L2Info)
+	Require(t, err)
+	err = checkTransferTxOnL2(t, ctx, builder.L2, "User17", builder.L2Info)
+	Require(t, err)
+
+	espressoStreamer.SetSGXVerifier(NewMockSgxTeeVerifier())
+	// Set this will cause the caff node to use the sgx verifier
+	espressoStreamer.SetBatcherAddressesFetcher(func(l1Height uint64, addr common.Address) (bool, error) { return false, nil })
+
+	err = waitForWith(ctx, 10*time.Minute, 10*time.Second, func() bool {
+		balance1 := builder2.L2.GetBalance(t, builder.L2Info.GetAddress("User16"))
+		balance2 := builder2.L2.GetBalance(t, builder.L2Info.GetAddress("User17"))
+		log.Info("waiting for balance", "account", "User16", "balance", balance1, "account", "User17", "balance", balance2)
+		return balance1.Cmp(transferAmount) > 0 && balance2.Cmp(transferAmount) > 0
+	})
+	Require(t, err)
+
+}
+
+func TestEspressoCaffNodeForceInclusionChecker(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	builder := NewNodeBuilder(ctx).DefaultConfig(t, true)
+	cleanup := builder.Build(t)
+	defer cleanup()
+
+	addr := builder.addresses.SequencerInbox
+	seqInbox, err := bridgegen.NewSequencerInbox(addr, builder.L1.Client)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	mockSeqInbox := &MockSeqInbox{
+		MaxDelayBlocks:  big.NewInt(20),
+		MaxDelaySeconds: big.NewInt(200),
+		seqInbox:        seqInbox,
+	}
+
+	config := arbnode.ForceInclusionCheckerConfig{
+		RetryTime:                time.Second * 2,
+		PollingInterval:          time.Second * 1,
+		BlockThresholdTolerance:  20,
+		SecondThresholdTolerance: 200,
+		ErrorToleranceDuration:   time.Minute * 10,
+	}
+
+	delayedBridge, err := arbnode.NewDelayedBridge(builder.L1.Client, builder.addresses.Bridge, builder.addresses.DeployedAt)
+	Require(t, err)
+
+	if builder.addresses.DeployedAt > math.MaxInt64 {
+		t.Fatal("deployedAt is greater than max int64")
+	}
+
+	// nolint:all
+	seqInboxInterface, err := arbnode.NewSequencerInbox(builder.L1.Client, builder.addresses.SequencerInbox, int64(builder.addresses.DeployedAt))
+	Require(t, err)
+
+	reader := builder.L2.ConsensusNode.L1Reader
+
+	fatalErrChan := make(chan error)
+
+	delayedMessageFetcher := arbnode.NewDelayedMessageFetcher(
+		delayedBridge,
+		reader,
+		false,
+		10,
+		0,
+		seqInboxInterface,
+		fatalErrChan,
+	)
+
+	forceInclusionChecker := arbnode.NewForceInclusionChecker(mockSeqInbox, config, reader, delayedMessageFetcher, fatalErrChan)
+	err = forceInclusionChecker.Start(ctx)
+	Require(t, err)
+
+	delayedTx := builder.L2Info.PrepareTx("Faucet", "Owner", 3e7, transferAmount, nil)
+	builder.L1.SendWaitTestTransactions(t, []*types.Transaction{
+		WrapL2ForDelayed(t, delayedTx, builder.L1Info, "Faucet", 100000),
+	})
+
+	select {
+	case err := <-fatalErrChan:
+		if err == nil {
+			t.Fatal("expected an error from fatalErrChan, got nil")
+		} else {
+			t.Logf("received error as expected: %v", err)
+		}
+	case <-time.After(100 * time.Second):
+		t.Fatal("did not receive error from fatalErrChan within timeout")
+	}
+}
+
+// MockSeqInbox is a mock implementation of the sequencer inbox interface,
+// allowing customizable time variation values for testing purposes.
+// This is useful because the real contract hardcodes MaxTimeVariation when deployBold is disabled.
+type MockSeqInbox struct {
+	MaxDelayBlocks  *big.Int
+	MaxDelaySeconds *big.Int
+	seqInbox        *bridgegen.SequencerInbox
+}
+
+func (m *MockSeqInbox) MaxTimeVariation(ctx context.Context) (*big.Int, *big.Int, *big.Int, *big.Int, error) {
+	return m.MaxDelayBlocks, nil, m.MaxDelaySeconds, nil, nil
+}
+
+func (m *MockSeqInbox) TotalDelayedMessagesRead(ctx context.Context) (*big.Int, error) {
+	return m.seqInbox.TotalDelayedMessagesRead(&bind.CallOpts{Context: ctx})
+}
+
+// system_tests/caff_node_test.go:25:2: "github.com/offchainlabs/nitro/espressostreamer" imported and not used (typecheck)
+//
+//	"github.com/offchainlabs/nitro/espressostreamer"
+//	^
+func UnusedEspressostreamer() espressostreamer.EspressoStreamerInterface {
+	var a espressostreamer.EspressoStreamerInterface
+	return a
+}
diff --git a/system_tests/common_test.go b/system_tests/common_test.go
index 5e7988175c2..c485730ee63 100644
--- a/system_tests/common_test.go
+++ b/system_tests/common_test.go
@@ -66,11 +66,13 @@ import (
 	"github.com/offchainlabs/nitro/cmd/chaininfo"
 	"github.com/offchainlabs/nitro/cmd/conf"
 	"github.com/offchainlabs/nitro/cmd/genericconf"
+	espresso_tee_utils "github.com/offchainlabs/nitro/cmd/util/espresso-tee-utils"
 	"github.com/offchainlabs/nitro/daprovider"
 	"github.com/offchainlabs/nitro/daprovider/das"
 	"github.com/offchainlabs/nitro/daprovider/das/dastree"
 	"github.com/offchainlabs/nitro/daprovider/das/dasutil"
 	"github.com/offchainlabs/nitro/deploy"
+	"github.com/offchainlabs/nitro/espresso/authdb"
 	"github.com/offchainlabs/nitro/execution/gethexec"
 	_ "github.com/offchainlabs/nitro/execution/nodeInterface"
 	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
@@ -119,6 +121,7 @@ type TestClient struct {
 	ClientWrapper          *ClientWrapper
 	ConsensusConfigFetcher ConfigFetcher[arbnode.Config]
 	ExecutionConfigFetcher ConfigFetcher[gethexec.Config]
+	caffDB                 *authdb.AuthDB
 
 	// having cleanup() field makes cleanup customizable from default cleanup methods after calling build
 	cleanup func()
@@ -302,6 +305,8 @@ type NodeBuilder struct {
 	L1 *TestClient
 	L2 *TestClient
 	L3 *TestClient
+
+	useL1StackConfig bool // don't overwrite the L1 stack config when building
 }
 
 type NitroConfig struct {
@@ -615,7 +620,13 @@ func (b *NodeBuilder) BuildL1(t *testing.T) {
 		t.Fatal(err)
 	}
 	b.L1 = NewTestClient(b.ctx)
-	b.L1Info, b.L1.Client, b.L1.L1Backend, b.L1.Stack, b.L1.ClientWrapper, b.L1.L1BlobReader = createTestL1BlockChain(t, b.L1Info, b.withL1ClientWrapper)
+
+	var l1StackConfig *node.Config
+	if b.useL1StackConfig {
+		l1StackConfig = b.l1StackConfig
+	}
+
+	b.L1Info, b.L1.Client, b.L1.L1Backend, b.L1.Stack, b.L1.ClientWrapper, b.L1.L1BlobReader = createTestL1BlockChainWithL1StackConfig(t, b.L1Info, l1StackConfig, b.withL1ClientWrapper)
 	locator, err := server_common.NewMachineLocator(b.valnodeConfig.Wasm.RootPath)
 	Require(t, err)
 	b.addresses, b.initMessage = deployOnParentChain(
@@ -666,7 +677,7 @@ func buildOnParentChain(
 	var arbDb ethdb.Database
 	var blockchain *core.BlockChain
 	_, chainTestClient.Stack, chainDb, arbDb, blockchain = createNonL1BlockChainWithStackConfig(
-		t, chainInfo, dataDir, chainConfig, arbOSInit, initMessage, stackConfig, execConfig)
+		t, chainInfo, dataDir, chainConfig, arbOSInit, initMessage, stackConfig, execConfig, nil)
 
 	var sequencerTxOptsPtr *bind.TransactOpts
 	var dataSigner signature.DataSignerFunc
@@ -699,8 +710,8 @@ func buildOnParentChain(
 	Require(t, err)
 	consensusConfigFetcher := NewCommonConfigFetcher(nodeConfig)
 	chainTestClient.ConsensusNode, err = arbnode.CreateNodeFullExecutionClient(
-		ctx, chainTestClient.Stack, execNode, execNode, execNode, execNode, arbDb, consensusConfigFetcher, blockchain.Config(), parentChainTestClient.Client,
-		addresses, validatorTxOptsPtr, sequencerTxOptsPtr, dataSigner, fatalErrChan, parentChainId, parentChainTestClient.L1BlobReader, locator.LatestWasmModuleRoot())
+		ctx, chainTestClient.Stack, execNode, execNode, execNode, execNode, arbDb, nil, consensusConfigFetcher, blockchain.Config(), parentChainTestClient.Client,
+		addresses, validatorTxOptsPtr, sequencerTxOptsPtr, dataSigner, fatalErrChan, parentChainId, parentChainTestClient.L1BlobReader, locator.LatestWasmModuleRoot(), nil)
 	Require(t, err)
 	chainTestClient.ConsensusConfigFetcher = consensusConfigFetcher
 
@@ -712,7 +723,12 @@ func buildOnParentChain(
 	StartWatchChanErr(t, ctx, fatalErrChan, chainTestClient.ConsensusNode)
 
 	chainTestClient.ExecNode = getExecNode(t, chainTestClient.ConsensusNode)
-	chainTestClient.cleanup = func() { chainTestClient.ConsensusNode.StopAndWait() }
+	chainTestClient.cleanup = func() {
+		chainTestClient.ConsensusNode.StopAndWait()
+		if chainTestClient.Stack != nil {
+			chainTestClient.Stack.Close()
+		}
+	}
 
 	chainTestClient.L1BlobReader = parentChainTestClient.L1BlobReader
 
@@ -846,7 +862,7 @@ func (b *NodeBuilder) BuildL2(t *testing.T) func() {
 	var arbDb ethdb.Database
 	var blockchain *core.BlockChain
 	b.L2Info, b.L2.Stack, chainDb, arbDb, blockchain = createNonL1BlockChainWithStackConfig(
-		t, b.L2Info, b.dataDir, b.chainConfig, b.arbOSInit, nil, b.l2StackConfig, b.execConfig)
+		t, b.L2Info, b.dataDir, b.chainConfig, b.arbOSInit, nil, b.l2StackConfig, b.execConfig, nil)
 
 	execConfigFetcher := NewCommonConfigFetcher(b.execConfig)
 	execNode, err := gethexec.CreateExecutionNode(b.ctx, b.L2.Stack, chainDb, blockchain, nil, execConfigFetcher, big.NewInt(1337), 0)
@@ -858,8 +874,8 @@ func (b *NodeBuilder) BuildL2(t *testing.T) func() {
 	Require(t, err)
 	consensusConfigFetcher := NewCommonConfigFetcher(b.nodeConfig)
 	b.L2.ConsensusNode, err = arbnode.CreateNodeFullExecutionClient(
-		b.ctx, b.L2.Stack, execNode, execNode, execNode, execNode, arbDb, consensusConfigFetcher, blockchain.Config(),
-		nil, nil, nil, nil, nil, fatalErrChan, big.NewInt(1337), nil, locator.LatestWasmModuleRoot())
+		b.ctx, b.L2.Stack, execNode, execNode, execNode, execNode, arbDb, nil, consensusConfigFetcher, blockchain.Config(),
+		nil, nil, nil, nil, nil, fatalErrChan, big.NewInt(1337), nil, locator.LatestWasmModuleRoot(), nil)
 	Require(t, err)
 	b.L2.ConsensusConfigFetcher = consensusConfigFetcher
 
@@ -889,13 +905,182 @@ func (b *NodeBuilder) BuildL2(t *testing.T) func() {
 	StartWatchChanErr(t, b.ctx, fatalErrChan, b.L2.ConsensusNode)
 
 	b.L2.ExecNode = getExecNode(t, b.L2.ConsensusNode)
-	b.L2.cleanup = func() { b.L2.ConsensusNode.StopAndWait() }
+	b.L2.cleanup = func() {
+		b.L2.ConsensusNode.StopAndWait()
+		if b.L2.Stack != nil {
+			b.L2.Stack.Close()
+		}
+	}
 	return func() {
 		b.L2.cleanup()
 		b.ctxCancel()
 	}
 }
 
+func (b *NodeBuilder) BuildEspressoCaffNode(t *testing.T, existing *NodeBuilder) (func(), error) {
+	existing.DontParalellise()
+	b.L2 = NewTestClient(b.ctx)
+	AddValNodeIfNeeded(t, b.ctx, b.nodeConfig, true, "", b.valnodeConfig.Wasm.RootPath)
+
+	l1Client := existing.L1.Client
+	deployInfo := existing.addresses
+
+	var chainDb ethdb.Database
+	var arbDb ethdb.Database
+	var blockchain *core.BlockChain
+
+	privKey := existing.L1Info.GetInfoWithPrivKey("User").PrivateKey
+
+	t.Setenv("CAFF_NODE_PRIV_KEY", common.Bytes2Hex(crypto.FromECDSA(privKey)))
+	b.L2Info, b.L2.Stack, chainDb, arbDb, blockchain = createL2BlockChain(t, b.L2Info, b.dataDir, b.chainConfig, existing.initMessage, b.l2StackConfig, b.execConfig)
+
+	Require(t, b.execConfig.Validate())
+	execConfig := b.execConfig
+	execConfigFetcher := NewCommonConfigFetcher(execConfig)
+	execNode, err := gethexec.CreateExecutionNode(b.ctx, b.L2.Stack, chainDb, blockchain, nil, execConfigFetcher, big.NewInt(1337), 0)
+	Require(t, err)
+
+	fatalErrChan := make(chan error, 10)
+	locator, err := server_common.NewMachineLocator(b.valnodeConfig.Wasm.RootPath)
+	Require(t, err)
+
+	b.L1Info = existing.L1Info
+	b.initMessage = existing.initMessage
+
+	teeHMAC, err := espresso_tee_utils.HmacForTest()
+	Require(t, err)
+	// For tests, we set the dataSigner == snapshotSigner because we are not running these tests in TEE mode.
+	caffNodeTxopts := existing.L1Info.GetDefaultTransactOpts("User", context.Background())
+	caffNodePrivateKey := existing.L1Info.GetInfoWithPrivKey("User").PrivateKey
+
+	var espressoCaffNodeInitArgs *arbnode.EspressoCaffNodeInitArgs
+	if existing.nodeConfig.Espresso.CaffNode.TeeType != "" {
+		initializeTags := false
+		if os.Getenv("INITIALIZE_TAGS") != "" {
+			initializeTags = true
+		}
+
+		espressoCaffNodeInitArgs = &arbnode.EspressoCaffNodeInitArgs{
+			TeeHMAC:                teeHMAC,
+			InitializeCaffNodeTags: initializeTags,
+			CaffNodetxOpts:         &caffNodeTxopts,
+			CaffNodePrivateKey:     caffNodePrivateKey,
+		}
+	}
+
+	consensusConfigFetcher := NewCommonConfigFetcher(b.nodeConfig)
+	b.L2.ConsensusNode, err = arbnode.CreateNodeFullExecutionClient(
+		b.ctx, b.L2.Stack, execNode, execNode, execNode, execNode, arbDb, chainDb, consensusConfigFetcher, blockchain.Config(),
+		l1Client, deployInfo, nil, nil, nil, fatalErrChan, big.NewInt(1337), nil, locator.LatestWasmModuleRoot(), espressoCaffNodeInitArgs)
+	Require(t, err)
+
+	err = b.L2.ConsensusNode.Start(b.ctx)
+
+	b.L2.Client = ClientForStack(t, b.L2.Stack)
+
+	StartWatchChanErr(t, b.ctx, fatalErrChan, b.L2.ConsensusNode)
+
+	b.L2.ExecNode = getExecNode(t, b.L2.ConsensusNode)
+	b.L2.cleanup = func() {
+		b.L2.ConsensusNode.StopAndWait()
+		if b.L2.Stack != nil {
+			b.L2.Stack.Close()
+		}
+	}
+	b.addresses = existing.addresses
+	return func() { b.L2.cleanup() }, err
+}
+
+// L2 -Only. RestartL2Node shutdowns the existing l2 node and start it again using the same data dir.
+func (b *NodeBuilder) RestartCaffNode(t *testing.T) {
+	if b.L2 == nil {
+		t.Fatalf("L2 was not created")
+	}
+	// Close caffDB explicitly to release tag freezer lock before closing stack
+	if b.L2.caffDB != nil {
+		if err := b.L2.caffDB.Close(); err != nil {
+			log.Warn("Error closing caffDB during restart", "err", err)
+		}
+		b.L2.caffDB = nil
+	}
+	// Now close the stack which will close all databases
+	if b.L2.Stack != nil {
+		err := b.L2.Stack.Close()
+		if err != nil {
+			log.Warn("Error closing stack during restart", "err", err)
+		}
+		b.L2.Stack = nil
+	}
+	// Give the OS time to release file handles and locks
+	// This is critical in CI environments where file system operations are slower
+	time.Sleep(500 * time.Millisecond)
+
+	caffNodePrivateKey := b.L1Info.GetInfoWithPrivKey("User").PrivateKey
+	t.Setenv("CAFF_NODE_PRIV_KEY", common.Bytes2Hex(crypto.FromECDSA(caffNodePrivateKey)))
+
+	l2info, stack, chainDb, arbDb, blockchain := createNonL1BlockChainWithStackConfig(t, b.L2Info, b.dataDir, b.chainConfig, b.arbOSInit, b.initMessage, b.l2StackConfig, b.execConfig, b.nodeConfig)
+
+	execConfigFetcher := NewCommonConfigFetcher(b.execConfig)
+	execNode, err := gethexec.CreateExecutionNode(b.ctx, stack, chainDb, blockchain, nil, execConfigFetcher, big.NewInt(1337), 0)
+	Require(t, err)
+
+	feedErrChan := make(chan error, 10)
+	locator, err := server_common.NewMachineLocator(b.valnodeConfig.Wasm.RootPath)
+	Require(t, err)
+
+	var currentNode *arbnode.Node
+	var caffDB *authdb.AuthDB
+	if b.nodeConfig.Espresso.CaffNode.TeeType != "" {
+		teeHMAC, err := espresso_tee_utils.HmacForTest()
+		caffNodeTxopts := b.L1Info.GetDefaultTransactOpts("User", context.Background())
+		Require(t, err)
+		caffNodePrivateKey := b.L1Info.GetInfoWithPrivKey("User").PrivateKey
+		initializeTags := false
+		if os.Getenv("INITIALIZE_TAGS") != "" {
+			initializeTags = true
+		}
+
+		espressoCaffNodeInitArgs := &arbnode.EspressoCaffNodeInitArgs{
+			TeeHMAC:                teeHMAC,
+			InitializeCaffNodeTags: initializeTags,
+			CaffNodetxOpts:         &caffNodeTxopts,
+			CaffNodePrivateKey:     caffNodePrivateKey,
+		}
+		currentNode, err = arbnode.CreateNodeFullExecutionClient(b.ctx, stack, execNode, execNode, execNode, execNode, arbDb, chainDb, NewCommonConfigFetcher(b.nodeConfig), blockchain.Config(), b.L1.Client, b.addresses, nil, nil, nil, feedErrChan, big.NewInt(1337), nil, locator.LatestWasmModuleRoot(), espressoCaffNodeInitArgs)
+		Require(t, err)
+	} else {
+		espressoCaffNodeInitArgs := &arbnode.EspressoCaffNodeInitArgs{
+			InitializeCaffNodeTags: false,
+		}
+		currentNode, err = arbnode.CreateNodeFullExecutionClient(b.ctx, stack, execNode, execNode, execNode, execNode, arbDb, chainDb, NewCommonConfigFetcher(b.nodeConfig), blockchain.Config(), b.L1.Client, b.addresses, nil, nil, nil, feedErrChan, big.NewInt(1337), nil, locator.LatestWasmModuleRoot(), espressoCaffNodeInitArgs)
+		Require(t, err)
+	}
+
+	Require(t, currentNode.Start(b.ctx))
+	client := ClientForStack(t, stack)
+
+	StartWatchChanErr(t, b.ctx, feedErrChan, currentNode)
+
+	l2 := NewTestClient(b.ctx)
+	l2.ConsensusNode = currentNode
+	l2.Client = client
+	l2.ExecNode = execNode
+	l2.caffDB = caffDB
+	l2.cleanup = func() {
+		currentNode.StopAndWait()
+		if l2.caffDB != nil {
+			l2.caffDB.Close()
+		}
+		if stack != nil {
+			stack.Close()
+		}
+	}
+	l2.Stack = stack
+
+	b.L2 = l2
+	b.L2Info = l2info
+}
+
 // L2 -Only. RestartL2Node shutdowns the existing l2 node and start it again using the same data dir.
 func (b *NodeBuilder) RestartL2Node(t *testing.T) {
 	if b.L2 == nil {
@@ -903,7 +1088,7 @@ func (b *NodeBuilder) RestartL2Node(t *testing.T) {
 	}
 	b.L2.cleanup()
 
-	l2info, stack, chainDb, arbDb, blockchain := createNonL1BlockChainWithStackConfig(t, b.L2Info, b.dataDir, b.chainConfig, b.arbOSInit, b.initMessage, b.l2StackConfig, b.execConfig)
+	l2info, stack, chainDb, arbDb, blockchain := createNonL1BlockChainWithStackConfig(t, b.L2Info, b.dataDir, b.chainConfig, b.arbOSInit, b.initMessage, b.l2StackConfig, b.execConfig, nil)
 
 	execConfigFetcher := NewCommonConfigFetcher(b.execConfig)
 	execNode, err := gethexec.CreateExecutionNode(b.ctx, stack, chainDb, blockchain, nil, execConfigFetcher, big.NewInt(1337), 0)
@@ -925,7 +1110,7 @@ func (b *NodeBuilder) RestartL2Node(t *testing.T) {
 		l1Client = b.L1.Client
 	}
 	consensusConfigFetcher := NewCommonConfigFetcher(b.nodeConfig)
-	currentNode, err := arbnode.CreateNodeFullExecutionClient(b.ctx, stack, execNode, execNode, execNode, execNode, arbDb, consensusConfigFetcher, blockchain.Config(), l1Client, b.addresses, validatorTxOpts, sequencerTxOpts, dataSigner, feedErrChan, big.NewInt(1337), nil, locator.LatestWasmModuleRoot())
+	currentNode, err := arbnode.CreateNodeFullExecutionClient(b.ctx, stack, execNode, execNode, execNode, execNode, arbDb, chainDb, consensusConfigFetcher, blockchain.Config(), l1Client, b.addresses, validatorTxOpts, sequencerTxOpts, dataSigner, feedErrChan, big.NewInt(1337), nil, locator.LatestWasmModuleRoot(), nil)
 	Require(t, err)
 
 	Require(t, currentNode.Start(b.ctx))
@@ -937,7 +1122,12 @@ func (b *NodeBuilder) RestartL2Node(t *testing.T) {
 	l2.ConsensusNode = currentNode
 	l2.Client = client
 	l2.ExecNode = execNode
-	l2.cleanup = func() { b.L2.ConsensusNode.StopAndWait() }
+	l2.cleanup = func() {
+		b.L2.ConsensusNode.StopAndWait()
+		if stack != nil {
+			stack.Close()
+		}
+	}
 	l2.Stack = stack
 	l2.ExecutionConfigFetcher = execConfigFetcher
 	l2.ConsensusConfigFetcher = consensusConfigFetcher
@@ -1484,11 +1674,14 @@ func AddValNode(t *testing.T, ctx context.Context, nodeConfig *arbnode.Config, u
 	configByValidationNode(nodeConfig, valStack)
 }
 
-func createTestL1BlockChain(t *testing.T, l1info info, withClientWrapper bool) (info, *ethclient.Client, *eth.Ethereum, *node.Node, *ClientWrapper, daprovider.BlobReader) {
+func createTestL1BlockChainWithL1StackConfig(t *testing.T, l1info info, stackConfig *node.Config, withClientWrapper bool) (info, *ethclient.Client, *eth.Ethereum, *node.Node, *ClientWrapper, daprovider.BlobReader) {
 	if l1info == nil {
 		l1info = NewL1TestInfo(t)
 	}
-	stackConfig := testhelpers.CreateStackConfigForTest("")
+
+	if stackConfig == nil {
+		stackConfig = testhelpers.CreateStackConfigForTest("")
+	}
 	l1info.GenerateAccount("Faucet")
 	for _, acct := range DefaultChainAccounts {
 		l1info.GenerateAccount(acct)
@@ -1622,6 +1815,16 @@ func deployOnParentChain(
 
 	nativeToken := common.Address{}
 	maxDataSize := big.NewInt(117964)
+
+	var espressoTEEVerifierAddress common.Address
+	var tx *types.Transaction
+
+	//  Deploy a espressoTEEVerifierMock contract
+	espressoTEEVerifierAddress, tx, _, err = deployMockTEEContracts(t, &parentChainTransactionOpts, parentChainClient)
+	Require(t, err)
+	_, err = parentChainReader.WaitForTxApproval(ctx, tx)
+	Require(t, err)
+
 	var addresses *chaininfo.RollupAddresses
 	if deployBold {
 		stakeToken, tx, _, err := localgen.DeployTestWETH9(
@@ -1671,6 +1874,7 @@ func deployOnParentChain(
 			NumBigStepLevel:              3,
 			ChallengeGracePeriodBlocks:   3,
 			BufferConfig:                 bufferConfig,
+			EspressoTEEVerifier:          espressoTEEVerifierAddress,
 		}
 		wrappedClient := butil.NewBackendWrapper(parentChainReader.Client(), rpc.LatestBlockNumber)
 		boldAddresses, err := setup.DeployFullRollupStack(
@@ -1700,6 +1904,8 @@ func deployOnParentChain(
 			DeployedAt:             boldAddresses.DeployedAt,
 		}
 	} else {
+		_, err = parentChainReader.WaitForTxApproval(ctx, tx)
+		Require(t, err)
 		addresses, err = deploy.DeployLegacyOnParentChain(
 			ctx,
 			parentChainReader,
@@ -1707,23 +1913,24 @@ func deployOnParentChain(
 			[]common.Address{parentChainInfo.GetAddress("Sequencer")},
 			parentChainInfo.GetAddress("RollupOwner"),
 			0,
-			deploy.GenerateLegacyRollupConfig(prodConfirmPeriodBlocks, wasmModuleRoot, parentChainInfo.GetAddress("RollupOwner"), chainConfig, serializedChainConfig, common.Address{}),
+			deploy.GenerateLegacyRollupConfig(prodConfirmPeriodBlocks, wasmModuleRoot, parentChainInfo.GetAddress("RollupOwner"), chainConfig, serializedChainConfig, common.Address{}, espressoTEEVerifierAddress),
 			nativeToken,
 			maxDataSize,
 			chainSupportsBlobs,
 		)
+		Require(t, err)
 	}
-	Require(t, err)
 	parentChainInfo.SetContract("Bridge", addresses.Bridge)
 	parentChainInfo.SetContract("SequencerInbox", addresses.SequencerInbox)
 	parentChainInfo.SetContract("Inbox", addresses.Inbox)
 	parentChainInfo.SetContract("UpgradeExecutor", addresses.UpgradeExecutor)
+	parentChainInfo.SetContract("EspressoTEEVerifierMock", espressoTEEVerifierAddress)
 	initMessage := getInitMessage(ctx, t, parentChainClient, addresses)
 	return addresses, initMessage
 }
 
 func createNonL1BlockChainWithStackConfig(
-	t *testing.T, info *BlockchainTestInfo, dataDir string, chainConfig *params.ChainConfig, arbOSInit *params.ArbOSInit, initMessage *arbostypes.ParsedInitMessage, stackConfig *node.Config, execConfig *gethexec.Config,
+	t *testing.T, info *BlockchainTestInfo, dataDir string, chainConfig *params.ChainConfig, arbOSInit *params.ArbOSInit, initMessage *arbostypes.ParsedInitMessage, stackConfig *node.Config, execConfig *gethexec.Config, nodeConfig *arbnode.Config,
 ) (*BlockchainTestInfo, *node.Node, ethdb.Database, ethdb.Database, *core.BlockChain) {
 	if info == nil {
 		info = NewArbTestInfo(t, chainConfig.ChainID)
@@ -1739,7 +1946,31 @@ func createNonL1BlockChainWithStackConfig(
 	stack, err := node.New(stackConfig)
 	Require(t, err)
 
-	chainData, err := stack.OpenDatabaseWithOptions("l2chaindata", node.DatabaseOptions{MetricsNamespace: "l2chaindata/", PebbleExtraOptions: conf.PersistentConfigDefault.Pebble.ExtraOptions("l2chaindata")})
+	var chainData ethdb.Database
+	// If snapshot mode is enabled, check if the snapshot hash matches the one in the config before opening the database in write mode
+	if nodeConfig != nil && nodeConfig.Espresso.CaffNode.SnapshotChecksum != "" {
+		log.Info("Snapshot mode enabled in Caff node")
+		if nodeConfig.Espresso.CaffNode.SnapshotChecksum == "" {
+			Fatal(t, "snapshot checksum should not be empty when snapshot mode is enabled")
+		}
+		privKey := os.Getenv("CAFF_NODE_PRIV_KEY")
+		if privKey == "" {
+			Fatal(t, "CAFF_NODE_PRIV_KEY environment variable is not set")
+		}
+		// Use the private key from the environment variable as needed
+		caffPrivKey, err := crypto.HexToECDSA(privKey)
+		if err != nil {
+			Fatal(t, "Invalid CAFF_NODE_PRIV_KEY format")
+		}
+		t.Setenv("INITIALIZE_TAGS", "")
+		initializeTags, err := arbutil.VerifySnapshot(nodeConfig.Espresso.CaffNode.SnapshotChecksum, stack.InstanceDir(), stack.ResolvePath("l2chaindata"), stack.ResolveAncient("l2chaindata", conf.PersistentConfigDefault.Ancient), caffPrivKey)
+		Require(t, err)
+		if initializeTags {
+			t.Setenv("INITIALIZE_TAGS", "true")
+		}
+	}
+
+	chainData, err = stack.OpenDatabaseWithOptions("l2chaindata", node.DatabaseOptions{MetricsNamespace: "l2chaindata/", PebbleExtraOptions: conf.PersistentConfigDefault.Pebble.ExtraOptions("l2chaindata")})
 	Require(t, err)
 
 	wasmData, err := stack.OpenDatabaseWithOptions("wasm", node.DatabaseOptions{MetricsNamespace: "wasm/", PebbleExtraOptions: conf.PersistentConfigDefault.Pebble.ExtraOptions("wasm"), NoFreezer: true})
@@ -1761,7 +1992,7 @@ func createNonL1BlockChainWithStackConfig(
 		}
 	}
 	coreCacheConfig := gethexec.DefaultCacheConfigFor(&execConfig.Caching)
-	blockchain, err := gethexec.WriteOrTestBlockChain(chainDb, coreCacheConfig, initReader, chainConfig, arbOSInit, nil, initMessage, &gethexec.ConfigDefault.TxIndexer, 0)
+	blockchain, err := gethexec.WriteOrTestBlockChain(chainDb, coreCacheConfig, initReader, chainConfig, arbOSInit, nil, initMessage, &execConfig.TxIndexer, 0)
 	Require(t, err)
 
 	return info, stack, chainDb, arbDb, blockchain
@@ -1874,9 +2105,9 @@ func Create2ndNodeWithConfig(
 	Require(t, err)
 	consensusConfigFetcher := NewCommonConfigFetcher(nodeConfig)
 	if useExecutionClientOnly {
-		currentNode, err = arbnode.CreateNodeExecutionClient(ctx, chainStack, currentExec, arbDb, consensusConfigFetcher, blockchain.Config(), parentChainClient, addresses, &validatorTxOpts, &sequencerTxOpts, dataSigner, feedErrChan, big.NewInt(1337), blobReader, locator.LatestWasmModuleRoot())
+		currentNode, err = arbnode.CreateNodeExecutionClient(ctx, chainStack, currentExec, arbDb, chainDb, consensusConfigFetcher, blockchain.Config(), parentChainClient, addresses, &validatorTxOpts, &sequencerTxOpts, dataSigner, feedErrChan, big.NewInt(1337), blobReader, locator.LatestWasmModuleRoot(), nil)
 	} else {
-		currentNode, err = arbnode.CreateNodeFullExecutionClient(ctx, chainStack, currentExec, currentExec, currentExec, currentExec, arbDb, consensusConfigFetcher, blockchain.Config(), parentChainClient, addresses, &validatorTxOpts, &sequencerTxOpts, dataSigner, feedErrChan, big.NewInt(1337), blobReader, locator.LatestWasmModuleRoot())
+		currentNode, err = arbnode.CreateNodeFullExecutionClient(ctx, chainStack, currentExec, currentExec, currentExec, currentExec, arbDb, chainDb, consensusConfigFetcher, blockchain.Config(), parentChainClient, addresses, &validatorTxOpts, &sequencerTxOpts, dataSigner, feedErrChan, big.NewInt(1337), blobReader, locator.LatestWasmModuleRoot(), nil)
 	}
 
 	Require(t, err)
@@ -2222,6 +2453,12 @@ func recordBlock(t *testing.T, block uint64, builder *NodeBuilder, targets ...ra
 	}
 }
 
+func createL2BlockChain(
+	t *testing.T, l2info *BlockchainTestInfo, dataDir string, chainConfig *params.ChainConfig, initMessage *arbostypes.ParsedInitMessage, nodeConf *node.Config, execConfig *gethexec.Config,
+) (*BlockchainTestInfo, *node.Node, ethdb.Database, ethdb.Database, *core.BlockChain) {
+	return createNonL1BlockChainWithStackConfig(t, l2info, dataDir, chainConfig, nil, initMessage, nodeConf, execConfig, nil)
+}
+
 func populateMachineDir(t *testing.T, cr *github.ConsensusRelease) string {
 	baseDir := t.TempDir()
 	machineDir := baseDir + "/machines"
@@ -2249,3 +2486,8 @@ func populateMachineDir(t *testing.T, cr *github.ConsensusRelease) string {
 	Require(t, err)
 	return machineDir
 }
+
+// nolint:unused
+func createTestL1BlockChain(t *testing.T, l1info info, withClientWrapper bool) (info, *ethclient.Client, *eth.Ethereum, *node.Node, *ClientWrapper, daprovider.BlobReader) {
+	return createTestL1BlockChainWithL1StackConfig(t, l1info, testhelpers.CreateStackConfigForTest(t.TempDir()), withClientWrapper)
+}
diff --git a/system_tests/espresso-e2e/.env b/system_tests/espresso-e2e/.env
new file mode 100644
index 00000000000..a095cf63f5d
--- /dev/null
+++ b/system_tests/espresso-e2e/.env
@@ -0,0 +1,7 @@
+ESPRESSO_SEQUENCER_L1_PROVIDER=http://host.docker.internal:8545
+ESPRESSO_SEQUENCER_ETH_MNEMONIC=indoor dish desk flag debris potato excuse depart ticket judge file exit
+ESPRESSO_DEPLOYER_ACCOUNT_INDEX=5
+ESPRESSO_SEQUENCER_API_PORT=41000
+ESPRESSO_BUILDER_PORT=41003
+ESPRESSO_DEV_NODE_PORT=20000
+ESPRESSO_DEV_NODE_EPOCH_HEIGHT=1000000
\ No newline at end of file
diff --git a/system_tests/espresso-e2e/docker-compose.yaml b/system_tests/espresso-e2e/docker-compose.yaml
new file mode 100644
index 00000000000..6a06b9a0ee8
--- /dev/null
+++ b/system_tests/espresso-e2e/docker-compose.yaml
@@ -0,0 +1,35 @@
+version: "3.9"
+services:
+  espresso-dev-node:
+    image: ghcr.io/espressosystems/espresso-sequencer/espresso-dev-node:release-20251120-lip2p-tcp-3855
+    ports:
+      - "$ESPRESSO_SEQUENCER_API_PORT:$ESPRESSO_SEQUENCER_API_PORT"
+      - "$ESPRESSO_BUILDER_PORT:$ESPRESSO_BUILDER_PORT"
+      - "$ESPRESSO_DEV_NODE_PORT:$ESPRESSO_DEV_NODE_PORT"
+    environment:
+      - ESPRESSO_BUILDER_PORT
+      - ESPRESSO_DEPLOYER_ACCOUNT_INDEX
+      - ESPRESSO_DEV_NODE_PORT
+      - ESPRESSO_SEQUENCER_API_PORT
+      - ESPRESSO_SEQUENCER_ETH_MNEMONIC
+      - ESPRESSO_SEQUENCER_L1_PROVIDER
+      - ESPRESSO_SEQUENCER_DATABASE_MAX_CONNECTIONS=25
+      - ESPRESSO_DEV_NODE_EPOCH_HEIGHT
+      - ESPRESSO_SEQUENCER_STORAGE_PATH=/data/espresso
+      # Currently we don't need the dev node to deploy Espresso contracts.
+      # We can skip them and save some time.
+      # These contract addresses are incorrect, but it doesn't matter.
+      - ESPRESSO_DEV_NODE_L1_DEPLOYMENT=skip
+      - ESPRESSO_SEQUENCER_LIGHT_CLIENT_PROXY_ADDRESS=0x0f1f89aaf1c6fdb7ff9d361e4388f5f3997f12a8
+      - ESPRESSO_SEQUENCER_STAKE_TABLE_ADDRESS=0x63e6dde6763c3466c7b45be880f7ee5dc2ca3e25
+      - ESPRESSO_SEQUENCER_STAKE_TABLE_PROXY_ADDRESS=0x9f5eac3d8e082f47631f1551f1343f23cd427162
+      - RUST_LOG=WARN
+      - RUST_LOG_FORMAT
+      - ESPRESSO_DEV_NODE_VERSION=0.4
+    volumes:
+      - espresso_storage:/data/espresso
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+
+volumes:
+  espresso_storage:
diff --git a/system_tests/espresso/chain/block_builder.go b/system_tests/espresso/chain/block_builder.go
new file mode 100644
index 00000000000..f0d26072a8a
--- /dev/null
+++ b/system_tests/espresso/chain/block_builder.go
@@ -0,0 +1,155 @@
+package chain
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	espresso_common "github.com/EspressoSystems/espresso-network/sdks/go/types/common"
+)
+
+// BlockBuilder is an interface that allows for the definition of different
+// Block Builders.
+//
+// This is utilized by the Mock Espresso Chain to determine which transactions
+// are included in each block being built.
+//
+// Having this interface allows for us to swap out different BlockBuilder
+// implementations, so that we can emulate ideal, and realistic scenarios.
+type BlockBuilder interface {
+	// SubmitTransaction submits a transaction to the block builder.
+	SubmitTransaction(ctx context.Context, tx espresso_common.Transaction) (*espresso_common.TaggedBase64, error)
+
+	// NextTransactions returns the next set of transactions to be included in
+	// the block being built.
+	NextTransactions() ([]espresso_common.Transaction, error)
+}
+
+// IdealBlockBuilder is a BlockBuilder that simply collects transactions
+// and returns them when NextTransactions is called.
+//
+// It is ideal in that it does not impose any restrictions on the size of
+// the transactions, and simply returns all transactions that have been
+// submitted so far.
+type IdealBlockBuilder struct {
+	lock         sync.Mutex
+	transactions []espresso_common.Transaction
+}
+
+// NewIdealBlockBuilder creates a new IdealBlockBuilder instance.
+func NewIdealBlockBuilder() *IdealBlockBuilder {
+	return &IdealBlockBuilder{}
+}
+
+// SubmitTransaction implements BlockBuilder
+func (b *IdealBlockBuilder) SubmitTransaction(ctx context.Context, tx espresso_common.Transaction) (*espresso_common.TaggedBase64, error) {
+	// Need to generate a unique hash for the transaction
+	tag, err := TransactionTaggedBase64(tx)
+	if err != nil {
+		return nil, ErrorSubmitTransaction{
+			Cause: err,
+		}
+	}
+
+	b.lock.Lock()
+	defer b.lock.Unlock()
+	b.transactions = append(b.transactions, tx)
+	return tag, nil
+}
+
+// NextTransactions implements BlockBuilder
+func (b *IdealBlockBuilder) NextTransactions() ([]espresso_common.Transaction, error) {
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	// Return the transactions that have been submitted so far.
+	txs := b.transactions
+	b.transactions = nil // Clear the transactions after returning them.
+	return txs, nil
+}
+
+// MaxSizeRestrictedBuilder is a BlockBuilder that restricts the size combined
+// transactions that are returned when NextTransactions is called.
+//
+// It additionally ensures that each individual transaction submitted does not
+// exceed the maximum size allowed for a transaction.
+type MaxSizeRestrictedBuilder struct {
+	lock                sync.Mutex
+	pendingTransactions []espresso_common.Transaction
+	maxSize             uint64
+}
+
+// NewMaxSizeRestrictedBuilder creates a new MaxSizeRestrictedBuilder with the
+// specified maximum size for transactions.
+func NewMaxSizeRestrictedBuilder(maxSize uint64) *MaxSizeRestrictedBuilder {
+	return &MaxSizeRestrictedBuilder{
+		maxSize: maxSize,
+	}
+}
+
+// ErrorTransactionTooLarge is an error that indicates that an individual
+// submitted transaction exceeds the maximum allowed size for a block by
+// itself.
+type ErrorTransactionTooLarge struct {
+	Transaction espresso_common.Transaction
+	MaxSize     uint64
+}
+
+// Error implements error
+func (e ErrorTransactionTooLarge) Error() string {
+	return fmt.Sprintf("transaction size %d exceeds maximum allowed size %d", len(e.Transaction.Payload), e.MaxSize)
+}
+
+// SubmitTransaction implements BlockBuilder
+func (b *MaxSizeRestrictedBuilder) SubmitTransaction(ctx context.Context, tx espresso_common.Transaction) (*espresso_common.TaggedBase64, error) {
+	// Need to generate a unique hash for the transaction
+	tag, err := TransactionTaggedBase64(tx)
+	if err != nil {
+		return nil, ErrorSubmitTransaction{
+			Cause: err,
+		}
+	}
+
+	if uint64(len(tx.Payload)) > b.maxSize {
+		return nil, ErrorTransactionTooLarge{
+			Transaction: tx,
+			MaxSize:     b.maxSize,
+		}
+	}
+
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	b.pendingTransactions = append(b.pendingTransactions, tx)
+	return tag, nil
+}
+
+// NextTransactions implements BlockBuilder
+func (b *MaxSizeRestrictedBuilder) NextTransactions() ([]espresso_common.Transaction, error) {
+	if len(b.pendingTransactions) == 0 {
+		return nil, nil // No transactions to return
+	}
+
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	nextPendingTxns := make([]espresso_common.Transaction, 0, len(b.pendingTransactions))
+	selectedTransactions := make([]espresso_common.Transaction, 0, len(b.pendingTransactions))
+
+	var totalSize uint64
+
+	for _, tx := range b.pendingTransactions {
+		txSize := uint64(len(tx.Payload))
+		if totalSize+txSize > b.maxSize {
+			nextPendingTxns = append(nextPendingTxns, tx)
+			continue
+		}
+
+		selectedTransactions = append(selectedTransactions, tx)
+		totalSize += txSize
+	}
+
+	// Clear the transactions after returning them.
+	b.pendingTransactions = nextPendingTxns
+	return selectedTransactions, nil
+}
diff --git a/system_tests/espresso/chain/doc.go b/system_tests/espresso/chain/doc.go
new file mode 100644
index 00000000000..9808bdd14de
--- /dev/null
+++ b/system_tests/espresso/chain/doc.go
@@ -0,0 +1,13 @@
+// Package chain provides mocks and implementations to simulate a simple
+// Espresso Chain environment for testing purposes.
+//
+// The point of this package is to provide a controllable environment
+// representation of the Espresso Chain.  As a result, it not only provides
+// the the Mock Espresso Chain, with the ability for the user to control when
+// the next block is produced / advanced, but it also provides several utilities
+// for simulating errant behavior.
+//
+// Additionally, it provides an UnimplementedEspressoClient, which can be used
+// to create other mocks that implement the EspressoClient interface without
+// needing to implement all methods.
+package chain
diff --git a/system_tests/espresso/chain/mock_espresso_chain.go b/system_tests/espresso/chain/mock_espresso_chain.go
new file mode 100644
index 00000000000..c48775342fe
--- /dev/null
+++ b/system_tests/espresso/chain/mock_espresso_chain.go
@@ -0,0 +1,408 @@
+package chain
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"sync"
+	"time"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+	tagged_base64 "github.com/EspressoSystems/espresso-network/sdks/go/tagged-base64"
+	espresso_types "github.com/EspressoSystems/espresso-network/sdks/go/types"
+	espresso_common "github.com/EspressoSystems/espresso-network/sdks/go/types/common"
+)
+
+// MockEspressoChain is a mock implementation of an Espresso Blockchain for
+// testing purposes.
+// It's meant to simulate a basic, likely incorrect and incomplete,
+// implementation of an Espresso chain.
+//
+// This implementation is not concerned with specifics or details about the
+// Espresso chain, and is not meant to be utilized as a sufficient substitute
+// for a real Espresso chain.
+//
+// What matters most about this implementation is that it allows the user to
+// control when new blocks are produced, and allows the user to submit, and
+// check for the existence of, transactions within the chain.
+type MockEspressoChain struct {
+	UnimplementedEspressoClient
+	Lock sync.RWMutex
+
+	Height       uint64
+	BlockBuilder BlockBuilder
+
+	BlockHeightStore map[uint64]BlockDetail
+	BlockHashStore   map[string]BlockDetail // This is not used in the mock, but kept for interface compatibility
+	TxnHashStore     map[string]TransactionDetail
+}
+
+// FetchHeaderByHeight implements client.EspressoClient.
+// Subtle: this method shadows the method (UnimplementedEspressoClient).FetchHeaderByHeight of MockEspressoChain.UnimplementedEspressoClient.
+func (m *MockEspressoChain) FetchHeaderByHeight(ctx context.Context, height uint64) (espresso_types.HeaderImpl, error) {
+	panic("unimplemented")
+}
+
+// FetchHeadersByRange implements client.EspressoClient.
+// Subtle: this method shadows the method (UnimplementedEspressoClient).FetchHeadersByRange of MockEspressoChain.UnimplementedEspressoClient.
+func (m *MockEspressoChain) FetchHeadersByRange(ctx context.Context, from uint64, until uint64) ([]espresso_types.HeaderImpl, error) {
+	panic("unimplemented")
+}
+
+// FetchNamespaceTransactionsInRange implements client.EspressoClient.
+func (m *MockEspressoChain) FetchNamespaceTransactionsInRange(ctx context.Context, fromHeight uint64, toHeight uint64, namespace uint64) ([]espresso_types.NamespaceTransactionsRangeData, error) {
+	panic("unimplemented")
+}
+
+// FetchRawHeaderByHeight implements client.EspressoClient.
+// Subtle: this method shadows the method (UnimplementedEspressoClient).FetchRawHeaderByHeight of MockEspressoChain.UnimplementedEspressoClient.
+func (m *MockEspressoChain) FetchRawHeaderByHeight(ctx context.Context, height uint64) (json.RawMessage, error) {
+	panic("unimplemented")
+}
+
+// FetchVidCommonByHeight implements client.EspressoClient.
+// Subtle: this method shadows the method (UnimplementedEspressoClient).FetchVidCommonByHeight of MockEspressoChain.UnimplementedEspressoClient.
+func (m *MockEspressoChain) FetchVidCommonByHeight(ctx context.Context, blockHeight uint64) (espresso_types.VidCommon, error) {
+	panic("unimplemented")
+}
+
+// StreamTransactions implements client.EspressoClient.
+func (m *MockEspressoChain) StreamTransactions(ctx context.Context, height uint64) (espresso_client.Stream[espresso_types.TransactionQueryData], error) {
+	panic("unimplemented")
+}
+
+// StreamTransactionsInNamespace implements client.EspressoClient.
+func (m *MockEspressoChain) StreamTransactionsInNamespace(ctx context.Context, height uint64, namespace uint64) (espresso_client.Stream[espresso_types.TransactionQueryData], error) {
+	panic("unimplemented")
+}
+
+// Ensure MockEspressoChain implements the EspressoClient interface.
+var _ espresso_client.EspressoClient = &MockEspressoChain{}
+
+// MockEspressoChainOption is a functional option type for configuring
+// MockEspressoChain instances.
+type MockEspressoChainOption func(*MockEspressoChain)
+
+// WithBlockHeight sets the initial block height for the MockEspressoChain.
+func WithBlockHeight(height uint64) MockEspressoChainOption {
+	return func(chain *MockEspressoChain) {
+		chain.Height = height
+	}
+}
+
+// WithBuilder sets the BlockBuilder for the MockEspressoChain.
+func WithBuilder(builder BlockBuilder) MockEspressoChainOption {
+	return func(chain *MockEspressoChain) {
+		chain.BlockBuilder = builder
+	}
+}
+
+// NewMockEspressoChain creates a new instance of MockEspressoChain with
+// initialized stores for blocks and transactions.
+func NewMockEspressoChain(options ...MockEspressoChainOption) *MockEspressoChain {
+	chain := &MockEspressoChain{
+		BlockBuilder:     NewIdealBlockBuilder(),
+		BlockHeightStore: make(map[uint64]BlockDetail),
+		BlockHashStore:   make(map[string]BlockDetail),
+		TxnHashStore:     make(map[string]TransactionDetail),
+	}
+
+	for _, option := range options {
+		option(chain)
+	}
+
+	return chain
+}
+
+// ErrorBlockNotFoundForHeight is an error type that indicates a block was not
+// found at a given height in the mock Espresso chain.
+type ErrorBlockNotFoundForHeight struct {
+	Height uint64
+}
+
+// Error implements error
+func (e ErrorBlockNotFoundForHeight) Error() string {
+	return fmt.Sprintf("block not found at height: %d", e.Height)
+}
+
+// ErrorFailedToComputeBlockHash is an error type that indicates a failure to
+// compute the hash of a block in the mock Espresso chain.
+type ErrorFailedToComputeBlockHash struct {
+	Cause error
+}
+
+// Error implements error
+func (e ErrorFailedToComputeBlockHash) Error() string {
+	return fmt.Sprintf("failed to compute block hash: %v", e.Cause)
+}
+
+// Advance simulates the advancement of the Espresso chain by creating a new
+// block with the list of pending transactions, advancing the height, and
+// storing the block and transaction details in their respective stores.
+func (m *MockEspressoChain) Advance() {
+	m.Lock.Lock()
+	defer m.Lock.Unlock()
+
+	// Let's "build" a new block
+	height := m.Height
+	m.Height++
+
+	pendingTxs, err := m.BlockBuilder.NextTransactions()
+	if err != nil {
+		panic(fmt.Sprintf("failed to get next transactions: %v", err))
+	}
+
+	block := BlockDetail{
+		Height:       height,
+		NumTxns:      uint64(len(pendingTxs)),
+		Transactions: pendingTxs,
+	}
+
+	blockTag, err := block.TaggedBase64()
+	if err != nil {
+		panic(fmt.Sprintf("failed to create tagged base64 for block: %v", err))
+	}
+
+	m.BlockHeightStore[height] = block
+	m.BlockHashStore[blockTag.String()] = block
+
+	for i, l := uint64(0), uint64(len(block.Transactions)); i < l; i++ {
+		tx := block.Transactions[i]
+		txTag, err := TransactionTaggedBase64(tx)
+		if err != nil {
+			panic(fmt.Sprintf("failed to create tagged base64 for transaction: %v", err))
+		}
+
+		txDetail := TransactionDetail{
+			Block:       height,
+			Index:       uint64(i),    // Index is not used in this mock
+			Namespace:   tx.Namespace, // Namespace is not used in this mock
+			Size:        uint64(len(tx.Payload)),
+			Transaction: tx,
+		}
+
+		m.TxnHashStore[txTag.String()] = txDetail
+	}
+}
+
+// FetchTransactionsInBlock retrieves the transactions in a block at a given
+// height and namespace. It returns an error if the block is not found.
+func (m *MockEspressoChain) FetchTransactionsInBlock(ctx context.Context, blockHeight uint64, namespace uint64) (espresso_client.TransactionsInBlock, error) {
+	m.Lock.RLock()
+	block, blockOk := m.BlockHeightStore[blockHeight]
+	m.Lock.RUnlock()
+	if !blockOk {
+		return espresso_client.TransactionsInBlock{}, ErrorBlockNotFoundForHeight{Height: blockHeight}
+	}
+
+	txns := make([]espresso_types.Bytes, 0, len(block.Transactions))
+	for _, tx := range block.Transactions {
+		txns = append(txns, espresso_types.Bytes(tx.Payload))
+	}
+	return espresso_client.TransactionsInBlock{
+		Transactions: txns,
+	}, nil
+}
+
+// ErrorInvalidHash is an error type that indicates an invalid hash was provided
+// when trying to fetch a transaction by its hash in the mock Espresso chain.
+type ErrorInvalidHash struct {
+	Hash *espresso_common.TaggedBase64
+}
+
+// Error implements error
+func (e ErrorInvalidHash) Error() string {
+	if e.Hash == nil {
+		return "invalid hash: nil"
+	}
+
+	return fmt.Sprintf("invalid hash: %s", e.Hash.String())
+}
+
+// ErrorTransactionNotFoundForHash is an error type that indicates a transaction
+// was not found for a given hash in the mock Espresso chain.
+type ErrorTransactionNotFoundForHash struct {
+	Hash espresso_common.TaggedBase64
+}
+
+// Error implements error
+func (e ErrorTransactionNotFoundForHash) Error() string {
+	return fmt.Sprintf("transaction not found for hash: %s", e.Hash.String())
+}
+
+// FetchTransactionByHash retrieves a transaction by its hash. It returns an
+// error if the hash is nil or if the transaction is not found in the mock
+// Espresso chain.
+func (m *MockEspressoChain) FetchTransactionByHash(ctx context.Context, hash *espresso_common.TaggedBase64) (espresso_types.TransactionQueryData, error) {
+	if hash == nil {
+		return espresso_types.TransactionQueryData{}, ErrorInvalidHash{
+			Hash: hash,
+		}
+	}
+
+	key := hash.String()
+	m.Lock.RLock()
+	txDetail, txDetailOk := m.TxnHashStore[key]
+	m.Lock.RUnlock()
+	if !txDetailOk {
+		return espresso_types.TransactionQueryData{}, ErrorTransactionNotFoundForHash{
+			Hash: *hash,
+		}
+	}
+
+	blockDetail, blockDetailOk := m.BlockHeightStore[txDetail.Block]
+	if !blockDetailOk {
+		return espresso_types.TransactionQueryData{}, ErrorBlockNotFoundForHeight{Height: txDetail.Block}
+	}
+
+	blockHash, err := blockDetail.TaggedBase64()
+	if err != nil {
+		return espresso_types.TransactionQueryData{}, ErrorFailedToComputeBlockHash{Cause: err}
+	}
+
+	return espresso_types.TransactionQueryData{
+		Transaction: txDetail.Transaction,
+		Hash:        hash,
+		Index:       txDetail.Index,
+		Proof:       json.RawMessage(`[]`), // Mocking proof as empty JSON array
+		BlockHash:   blockHash,
+		BlockHeight: blockDetail.Height,
+	}, nil
+}
+
+// FetchExplorerTransactionByHash retrieves transaction details for a given
+// hash from the mock Espresso chain.
+func (m *MockEspressoChain) FetchExplorerTransactionByHash(ctx context.Context, hash *espresso_types.TaggedBase64) (espresso_types.ExplorerTransactionQueryData, error) {
+	if hash == nil {
+		return espresso_types.ExplorerTransactionQueryData{}, ErrorInvalidHash{
+			Hash: hash,
+		}
+	}
+
+	key := hash.String()
+	m.Lock.RLock()
+	txDetail, txDetailOk := m.TxnHashStore[key]
+	m.Lock.RUnlock()
+	if !txDetailOk {
+		return espresso_types.ExplorerTransactionQueryData{}, ErrorTransactionNotFoundForHash{
+			Hash: *hash,
+		}
+	}
+
+	return espresso_types.ExplorerTransactionQueryData{
+		TransactionsDetails: espresso_common.ExplorerTransactionsDetails{
+			ExplorerDetails: espresso_common.ExplorerDetails{
+				BlockHeight: txDetail.Block,
+				Hash:        *hash,
+			},
+		},
+	}, nil
+}
+
+// ErrorSubmitTransaction is an error type that indicates a failure to submit
+// a transaction to the mock Espresso chain.
+type ErrorSubmitTransaction struct {
+	Cause error
+}
+
+// Error implements error
+func (e ErrorSubmitTransaction) Error() string {
+	return fmt.Sprintf("failed to submit transaction: %v", e.Cause)
+}
+
+// SubmitTransaction simulates the submission of a transaction to the mock
+// Espresso chain. It generates a unique hash for the transaction, appends it
+// to the list of pending transactions, and returns the generated hash.
+func (m *MockEspressoChain) SubmitTransaction(ctx context.Context, tx espresso_common.Transaction) (*espresso_common.TaggedBase64, error) {
+	return m.BlockBuilder.SubmitTransaction(ctx, tx)
+}
+
+// FetchLatestBlockHeight retrieves the latest block height from the mock
+// Espresso chain. It returns the current height and does not produce an error.
+// This method is used to simulate the behavior of fetching the latest block
+// height in a real Espresso chain.
+//
+// NOTE: This method does not acquire a lock, as it only reads the current
+// height, which should be safe to do.
+func (m *MockEspressoChain) FetchLatestBlockHeight(ctx context.Context) (uint64, error) {
+	return m.Height, nil
+}
+
+// ProduceEspressoBlocksAtInterval is a convenience function that calls
+// Advance on the provided MockEspressoChain at a specified interval.
+//
+// It is meant to be spawned in a separate goroutine to simulate the
+// production of blocks in the Espresso chain at regular intervals.
+//
+// NOTE: This can be used to simulate a live Espresso chain that produces blocks
+// at a given interval, which can be useful for testing purposes.
+func ProduceEspressoBlocksAtInterval(ctx context.Context, chain *MockEspressoChain, interval time.Duration) {
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	ticker := time.NewTicker(interval)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			chain.Advance()
+		}
+	}
+}
+
+// BlockDetail represents the minimal amount of information needed to represent
+// a Block in the Espresso chain for testing purposes.
+type BlockDetail struct {
+	Height       uint64
+	NumTxns      uint64
+	Transactions []espresso_common.Transaction
+}
+
+// Commit returns a commitment for the BlockDetail which is comprised of its
+// contents.
+func (b BlockDetail) Commit() espresso_common.Commitment {
+	builder := espresso_common.NewRawCommitmentBuilder("BlockDetail").
+		Uint64Field("height", b.Height)
+
+	for _, tx := range b.Transactions {
+		tCommit := tx.Commit()
+		builder.VarSizeBytes(espresso_common.Bytes(tCommit[:]))
+	}
+
+	return builder.
+		Finalize()
+}
+
+// TaggedBase64 is a convenience method to create a TaggedBase64
+func (b BlockDetail) TaggedBase64() (*espresso_common.TaggedBase64, error) {
+	commitment := b.Commit()
+	tag, err := tagged_base64.New("MOCK-BLOCK", commitment[:])
+	if err != nil {
+		return nil, fmt.Errorf("failed to create tagged base64 for block: %w", err)
+	}
+	return tag, nil
+}
+
+// TransactionDetail represents the minimal amount of information needed to
+// represent a Transaction in the Espresso chain for testing purposes.
+type TransactionDetail struct {
+	Block       uint64
+	Index       uint64
+	Namespace   uint64
+	Size        uint64
+	Transaction espresso_common.Transaction
+}
+
+// TransactionTaggedBase64 is a convenience method to create a TaggedBase64
+// for a TransactionDetail.
+func TransactionTaggedBase64(tx espresso_common.Transaction) (*espresso_common.TaggedBase64, error) {
+	commitment := tx.Commit()
+	tag, err := tagged_base64.New("MOCK-TXN", commitment[:])
+	if err != nil {
+		return nil, fmt.Errorf("failed to create tagged base64 for transaction: %w", err)
+	}
+
+	return tag, nil
+}
diff --git a/system_tests/espresso/chain/mock_espresso_chain_test.go b/system_tests/espresso/chain/mock_espresso_chain_test.go
new file mode 100644
index 00000000000..38adf4a5aef
--- /dev/null
+++ b/system_tests/espresso/chain/mock_espresso_chain_test.go
@@ -0,0 +1,240 @@
+package chain_test
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	tagged_base64 "github.com/EspressoSystems/espresso-network/sdks/go/tagged-base64"
+	espresso_common "github.com/EspressoSystems/espresso-network/sdks/go/types/common"
+
+	"github.com/offchainlabs/nitro/system_tests/espresso/chain"
+)
+
+// ExampleNewMockEspressoChain demonstrates how to create and utilize the
+// MockEspressoChain.
+func ExampleNewMockEspressoChain() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// Create a new mock Espresso chain
+	mockChain := chain.NewMockEspressoChain()
+
+	// The Mock Chain is simplified representation of an Espresso Chain
+	// that allows the consumer control over when the chain advances and
+	// produces the next block.
+	//
+	// This approach allows for the flexibility of controlling specific
+	// progression patterns that might result in edge cases that can
+	// be reproduced.
+
+	{
+		fmt.Println()
+		// The chain starts at height 0, and will only Advance, when
+		// the Advance method is called.
+
+		height, err := mockChain.FetchLatestBlockHeight(ctx)
+		if err != nil {
+			panic(fmt.Errorf("error fetching latest block height: %w\n", err))
+		}
+
+		fmt.Printf("Starting Block Height: %d\n", height)
+
+		// Advance the chain to the next block.
+		mockChain.Advance()
+
+		height, err = mockChain.FetchLatestBlockHeight(ctx)
+		if err != nil {
+			panic(fmt.Errorf("error fetching latest block height after advance: %w\n", err))
+		}
+		fmt.Printf("After Advance Block Height: %d\n", height)
+	}
+
+	{
+		fmt.Println()
+		// If we submit a transaction, it will not immediately result in a block
+		// but instead will be pending until the next Advance call.
+		// Once the next Advance call occurs, the pending transactions will
+		// be included in the next block.
+
+		txHash, err := mockChain.SubmitTransaction(ctx, espresso_common.Transaction{
+			Namespace: 1234,
+			Payload:   []byte("example transaction payload"),
+		})
+
+		if err != nil {
+			panic(fmt.Errorf("error submitting transaction: %w\n", err))
+		}
+
+		fmt.Printf("Submitted transaction with hash: %s\n", txHash)
+
+		// If we try to grab the block for the transaction now, it will not be
+		// found
+
+		_, err = mockChain.FetchTransactionByHash(ctx, txHash)
+		if err == nil {
+			// This is an error
+			panic(fmt.Errorf("expected error fetching transaction by hash, but received no error"))
+		}
+
+		fmt.Printf("Lookup for transaction by hash returned error: %s\n", err)
+
+		// Advance the chain to produce the next block
+		mockChain.Advance()
+
+		// Now we can fetch the transaction by hash, and it should be found
+		txData, err := mockChain.FetchTransactionByHash(ctx, txHash)
+		if err != nil {
+			panic(fmt.Errorf("error fetching transaction by hash after advance: %w\n", err))
+		}
+
+		fmt.Printf("Fetched transaction by hash: %s\n", txData.Hash)
+
+		// This will also allow us to fetch all of the transactions within the
+		// block
+
+		txsInBlock, err := mockChain.FetchTransactionsInBlock(ctx, 1, 1234)
+		if err != nil {
+			panic(fmt.Errorf("error fetching transactions in block: %w\n", err))
+		}
+
+		for i, tx := range txsInBlock.Transactions {
+			fmt.Printf("Transaction in block [%d]: \"%s\"\n", i, tx)
+		}
+
+		// As an alternative, we can also fetch the explorer block information.
+		explorerBlock, err := mockChain.FetchExplorerTransactionByHash(ctx, txHash)
+		if err != nil {
+			panic(fmt.Errorf("error fetching explorer transaction by hash: %w\n", err))
+		}
+
+		fmt.Printf("Explorer Block Height: %d\n", explorerBlock.TransactionsDetails.ExplorerDetails.BlockHeight)
+		fmt.Printf("Explorer Block Hash: %s\n", explorerBlock.TransactionsDetails.ExplorerDetails.Hash.String())
+	}
+
+	// Output:
+	// Starting Block Height: 0
+	// After Advance Block Height: 1
+	//
+	// Submitted transaction with hash: MOCK-TXN~Q8U3UD4JrPhZfR24S5u7ulmWIj48P6AlHxxeQF-xUmfI
+	// Lookup for transaction by hash returned error: transaction not found for hash: MOCK-TXN~Q8U3UD4JrPhZfR24S5u7ulmWIj48P6AlHxxeQF-xUmfI
+	// Fetched transaction by hash: MOCK-TXN~Q8U3UD4JrPhZfR24S5u7ulmWIj48P6AlHxxeQF-xUmfI
+	// Transaction in block [0]: "example transaction payload"
+	// Explorer Block Height: 1
+	// Explorer Block Hash: MOCK-TXN~Q8U3UD4JrPhZfR24S5u7ulmWIj48P6AlHxxeQF-xUmfI
+}
+
+// ExampleProduceEspressoBlocksAtInterval demonstrates how to produce blocks
+// at a regular interval using the MockEspressoChain, to more accurately
+// reflect the real Espresso Chain.
+func ExampleProduceEspressoBlocksAtInterval() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// Create a new mock Espresso chain
+	mockChain := chain.NewMockEspressoChain()
+
+	{
+		produceCtx, produceCancel := context.WithCancel(ctx)
+
+		// We tell the mock chain to produce blocks at a 2 second interval,
+		// to simulate a real Espresso chain that produces blocks at a regular
+		// interval.
+		go chain.ProduceEspressoBlocksAtInterval(produceCtx, mockChain, 2*time.Second)
+
+		// Allow some time for blocks to be produced
+		time.Sleep(5 * time.Second)
+
+		// Stop the production of blocks
+		produceCancel()
+	}
+
+	// Fetch the latest block height to verify that blocks were produced
+	height, err := mockChain.FetchLatestBlockHeight(ctx)
+	if err != nil {
+		panic(fmt.Errorf("error fetching latest block height: %w\n", err))
+	}
+
+	fmt.Printf("Latest Block Height after producing blocks: %d\n", height)
+
+	// Output:
+	// Latest Block Height after producing blocks: 2
+}
+
+// ExampleErrorBlockNotFoundForHeight demonstrates how to create an error
+// for a block not found at a specific height, which can occur if the block
+// has not been produced yet or has been pruned.
+func ExampleErrorBlockNotFoundForHeight() {
+	err := chain.ErrorBlockNotFoundForHeight{
+		Height: 1,
+	}
+	fmt.Printf("Error: %s\n", err.Error())
+
+	// Output: Error: block not found at height: 1
+}
+
+// ExampleErrorFailedToComputeBlockHash demonstrates how to create an error
+// for a failure in computing the block hash, which can occur if the block
+// data is invalid or corrupted.
+func ExampleErrorFailedToComputeBlockHash() {
+	err := chain.ErrorFailedToComputeBlockHash{
+		Cause: errors.New("example error"),
+	}
+	fmt.Printf("Error: %s\n", err.Error())
+
+	// Output: Error: failed to compute block hash: example error
+}
+
+// ExampleErrorInvalidHash demonstrates how to create an error
+// for an invalid hash, which can be nil or malformed.
+func ExampleErrorInvalidHash() {
+	{
+		err := chain.ErrorInvalidHash{}
+		fmt.Printf("Error nil hash: %s\n", err.Error())
+	}
+
+	{
+		tag, err := tagged_base64.New("EXAMPLE", nil)
+		if err != nil {
+			panic(fmt.Sprintf("failed to create tagged base64: %v\n", err))
+		}
+
+		err = chain.ErrorInvalidHash{
+			Hash: tag,
+		}
+
+		fmt.Printf("Error with hash: %s\n", err.Error())
+	}
+
+	// Output: Error nil hash: invalid hash: nil
+	// Error with hash: invalid hash: EXAMPLE~2A
+}
+
+// ExampleErrorTransactionNotFoundForHash demonstrates how to create an error
+// for a transaction not found by its hash.
+func ExampleErrorTransactionNotFoundForHash() {
+	tag, err := tagged_base64.New("EXAMPLE", nil)
+	if err != nil {
+		panic(fmt.Sprintf("failed to create tagged base64: %v\n", err))
+	}
+
+	err = chain.ErrorTransactionNotFoundForHash{
+		Hash: *tag,
+	}
+
+	fmt.Printf("Error: %s\n", err.Error())
+
+	// Output: Error: transaction not found for hash: EXAMPLE~2A
+}
+
+// ExampleErrorSubmitTransaction demonstrates how to create an error
+// for a failed transaction submission.
+func ExampleErrorSubmitTransaction() {
+	err := chain.ErrorSubmitTransaction{
+		Cause: errors.New("failed to submit transaction"),
+	}
+	fmt.Printf("Error: %s\n", err.Error())
+
+	// Output: Error: failed to submit transaction: failed to submit transaction
+}
diff --git a/system_tests/espresso/chain/simulated_latency.go b/system_tests/espresso/chain/simulated_latency.go
new file mode 100644
index 00000000000..a6cbc9d3ab2
--- /dev/null
+++ b/system_tests/espresso/chain/simulated_latency.go
@@ -0,0 +1,152 @@
+package chain
+
+import (
+	"context"
+	"time"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+	espresso_types "github.com/EspressoSystems/espresso-network/sdks/go/types"
+	espresso_common "github.com/EspressoSystems/espresso-network/sdks/go/types/common"
+)
+
+// EspressoClientSimulatedLatency is a wrapper around an Espresso chain client
+// that introduces a delay before executing any method calls. This can be
+// useful for simulating network latency or for testing purposes.
+type EspressoClientSimulatedLatency struct {
+	espresso_client.EspressoClient
+	transactionsInBlockDelay time.Duration
+	transactionsByHashDelay  time.Duration
+	submitTransactionDelay   time.Duration
+	explorerTransactionDelay time.Duration
+}
+
+// SimulatedLatencyConfig holds the configuration for creating the
+// EspressoClientSimulatedLatency. It includes the client and the delays for
+// the various method calls.
+type SimulatedLatencyConfig struct {
+	EspressoClient           espresso_client.EspressoClient
+	TransactionsInBlockDelay time.Duration
+	TransactionsByHashDelay  time.Duration
+	SubmitTransactionDelay   time.Duration
+	ExplorerTransactionDelay time.Duration
+}
+
+// SimulatedLatencyOption is a function that modifies the
+// SimulatedLatencyConfig. This allows for flexible configuration of the
+// simulated latency without hardcoding values in the client implementation.
+type SimulatedLatencyOption func(*SimulatedLatencyConfig)
+
+// Ensure that SimulatedLatencyEspressoChain implements EspressoClient
+var _ espresso_client.EspressoClient = &EspressoClientSimulatedLatency{}
+
+// WithTransactionsInBlockDelay sets the delay for the FetchTransactionsInBlock
+// method.
+func WithTransactionsInBlockDelay(delay time.Duration) SimulatedLatencyOption {
+	return func(config *SimulatedLatencyConfig) {
+		config.TransactionsInBlockDelay = delay
+	}
+}
+
+// WithTransactionsByHashDelay sets the delay for the FetchTransactionByHash
+// method.
+func WithTransactionsByHashDelay(delay time.Duration) SimulatedLatencyOption {
+	return func(config *SimulatedLatencyConfig) {
+		config.TransactionsByHashDelay = delay
+	}
+}
+
+// WithSubmitTransactionDelay sets the delay for the SubmitTransaction method.
+func WithSubmitTransactionDelay(delay time.Duration) SimulatedLatencyOption {
+	return func(config *SimulatedLatencyConfig) {
+		config.SubmitTransactionDelay = delay
+	}
+}
+
+// WithExplorerTransactionDelay sets the delay for the
+// FetchExplorerTransactionByHash method.
+func WithExplorerTransactionDelay(delay time.Duration) SimulatedLatencyOption {
+	return func(config *SimulatedLatencyConfig) {
+		config.ExplorerTransactionDelay = delay
+	}
+}
+
+// applySimulatedLatencyOptions applies the provided options to the
+// SimulatedLatencyConfig. This allows for multiple options to be applied in a
+// single call, making it easier to configure the client.
+func applySimulatedLatencyOptions(config *SimulatedLatencyConfig, options ...SimulatedLatencyOption) {
+	for _, option := range options {
+		option(config)
+	}
+}
+
+// WithAllDelaysSetTo is a SimulatedLatencyOption that sets all delays to the
+// same value.
+func WithAllDelaysSetTo(delay time.Duration) SimulatedLatencyOption {
+	return func(config *SimulatedLatencyConfig) {
+		applySimulatedLatencyOptions(config,
+			WithTransactionsInBlockDelay(delay),
+			WithTransactionsByHashDelay(delay),
+			WithSubmitTransactionDelay(delay),
+			WithExplorerTransactionDelay(delay),
+		)
+	}
+}
+
+// NewEspressoClientSimulatedLatency creates a new instance of EspressoChainDelayed
+// with the specified chain client and delay duration. The delay will be applied
+// to all method calls made to the chain client.
+func NewEspressoClientSimulatedLatency(client espresso_client.EspressoClient, options ...SimulatedLatencyOption) *EspressoClientSimulatedLatency {
+	const defaultDelay = 250 * time.Millisecond
+	config := SimulatedLatencyConfig{
+		EspressoClient:           client,
+		TransactionsInBlockDelay: defaultDelay,
+		TransactionsByHashDelay:  defaultDelay,
+		SubmitTransactionDelay:   defaultDelay,
+		ExplorerTransactionDelay: defaultDelay,
+	}
+
+	applySimulatedLatencyOptions(&config, options...)
+
+	return &EspressoClientSimulatedLatency{
+		EspressoClient:           config.EspressoClient,
+		transactionsInBlockDelay: config.TransactionsInBlockDelay,
+		transactionsByHashDelay:  config.TransactionsByHashDelay,
+		submitTransactionDelay:   config.SubmitTransactionDelay,
+		explorerTransactionDelay: config.ExplorerTransactionDelay,
+	}
+}
+
+// This is a compile time check to ensure that MockEspressoChain implements
+// EspressoClient.
+var _ espresso_client.EspressoClient = &MockEspressoChain{}
+
+// FetchTransactionsInBlock implements espresso_client.EspressoClient
+func (c *EspressoClientSimulatedLatency) FetchTransactionsInBlock(ctx context.Context, blockHeight uint64, namespace uint64) (espresso_client.TransactionsInBlock, error) {
+	time.Sleep(c.transactionsInBlockDelay)
+	return c.EspressoClient.FetchTransactionsInBlock(ctx, blockHeight, namespace)
+}
+
+// FetchTransactionByHash implements espresso_client.EspressoClient
+func (c *EspressoClientSimulatedLatency) FetchTransactionByHash(ctx context.Context, hash *espresso_types.TaggedBase64) (espresso_types.TransactionQueryData, error) {
+	time.Sleep(c.transactionsByHashDelay)
+	return c.EspressoClient.FetchTransactionByHash(ctx, hash)
+}
+
+// SubmitTransaction implements espresso_client.EspressoClient
+func (c *EspressoClientSimulatedLatency) SubmitTransaction(ctx context.Context, tx espresso_common.Transaction) (*espresso_common.TaggedBase64, error) {
+	time.Sleep(c.submitTransactionDelay)
+	return c.EspressoClient.SubmitTransaction(ctx, tx)
+}
+
+// FetchExplorerTransactionByHash implements espresso_client.EspressoClient
+func (c *EspressoClientSimulatedLatency) FetchExplorerTransactionByHash(ctx context.Context, hash *espresso_types.TaggedBase64) (espresso_types.ExplorerTransactionQueryData, error) {
+	time.Sleep(c.explorerTransactionDelay)
+	return c.EspressoClient.FetchExplorerTransactionByHash(ctx, hash)
+}
+
+// FetchNamespaceTransactionsInRange implements espresso_client.EspressoClient
+func (c *EspressoClientSimulatedLatency) FetchNamespaceTransactionsInRange(ctx context.Context, fromBlock uint64, toBlock uint64, namespace uint64) ([]espresso_types.NamespaceTransactionsRangeData, error) {
+	time.Sleep(c.transactionsInBlockDelay)
+	time.Sleep(c.transactionsInBlockDelay)
+	return c.EspressoClient.FetchNamespaceTransactionsInRange(ctx, fromBlock, toBlock, namespace)
+}
diff --git a/system_tests/espresso/chain/simulated_latency_test.go b/system_tests/espresso/chain/simulated_latency_test.go
new file mode 100644
index 00000000000..66da1f9c37e
--- /dev/null
+++ b/system_tests/espresso/chain/simulated_latency_test.go
@@ -0,0 +1,57 @@
+package chain_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	espresso_common "github.com/EspressoSystems/espresso-network/sdks/go/types/common"
+
+	"github.com/offchainlabs/nitro/system_tests/espresso/chain"
+)
+
+// expectDelay is a helper function that runs the provided function and checks
+// if the execution time is at least the expected delay.
+func expectDelay(t *testing.T, target time.Duration, fn func()) {
+	start := time.Now()
+	fn()
+	end := time.Now()
+
+	if have, want := end.Sub(start), target; have < want {
+		t.Errorf("call didn't take as long as expected:\nhave:\n\t\"%v\"\nwant greater than or equal to:\n\t\"%v\"", have, want)
+	}
+}
+
+// TestSimulatedLatency tests the EspressoClientSimulatedLatency wrapper to
+// ensure that it introduces the expected delays for various methods
+// invocations.
+func TestSimulatedLatency(t *testing.T) {
+	mockChain := chain.NewMockEspressoChain()
+	delay := 100 * time.Millisecond
+
+	latencyClient := chain.NewEspressoClientSimulatedLatency(mockChain, chain.WithAllDelaysSetTo(delay))
+
+	t.Run("FetchTransactionsInBlock", func(t *testing.T) {
+		expectDelay(t, delay, func() {
+			_, _ = latencyClient.FetchTransactionsInBlock(context.Background(), 1, 1)
+		})
+	})
+
+	t.Run("FetchTransactionByHash", func(t *testing.T) {
+		expectDelay(t, delay, func() {
+			_, _ = latencyClient.FetchTransactionByHash(context.Background(), nil)
+		})
+	})
+
+	t.Run("SubmitTransaction", func(t *testing.T) {
+		expectDelay(t, delay, func() {
+			_, _ = latencyClient.SubmitTransaction(context.Background(), espresso_common.Transaction{})
+		})
+	})
+
+	t.Run("FetchExplorerTransactionByHash", func(t *testing.T) {
+		expectDelay(t, delay, func() {
+			_, _ = latencyClient.FetchExplorerTransactionByHash(context.Background(), nil)
+		})
+	})
+}
diff --git a/system_tests/espresso/chain/siphon_blocks.go b/system_tests/espresso/chain/siphon_blocks.go
new file mode 100644
index 00000000000..181a537550a
--- /dev/null
+++ b/system_tests/espresso/chain/siphon_blocks.go
@@ -0,0 +1,43 @@
+package chain
+
+import (
+	"context"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+)
+
+// SiphonBlocksWithTransactions is a wrapper around an Espresso client that
+// fetches transactions in blocks and sends them to a channel. This is useful
+// for siphoning blocks with their transactions in a streaming manner, allowing
+// for real-time inspection of transaction data as they are fetched
+// successfully.
+type SiphonBlocksWithTransactions struct {
+	espresso_client.EspressoClient
+	ch chan<- espresso_client.TransactionsInBlock
+}
+
+var _ espresso_client.EspressoClient = &SiphonBlocksWithTransactions{}
+
+// NewSiphonBlocksWithTransactions creates a new instance of
+// SiphonBlocksWithTransactions with the specified Espresso client and channel.
+func NewSiphonBlocksWithTransactions(
+	client espresso_client.EspressoClient,
+	ch chan<- espresso_client.TransactionsInBlock,
+) *SiphonBlocksWithTransactions {
+	return &SiphonBlocksWithTransactions{
+		EspressoClient: client,
+		ch:             ch,
+	}
+}
+
+// FetchTransactionsInBlock implements espresso_client.EspressoClient
+func (c *SiphonBlocksWithTransactions) FetchTransactionsInBlock(ctx context.Context, blockHeight uint64, namespace uint64) (espresso_client.TransactionsInBlock, error) {
+	result, err := c.EspressoClient.FetchTransactionsInBlock(ctx, blockHeight, namespace)
+	if err != nil {
+		return result, err
+	}
+
+	// Send the result to the channel
+	c.ch <- result
+	return result, err
+}
diff --git a/system_tests/espresso/chain/siphon_blocks_test.go b/system_tests/espresso/chain/siphon_blocks_test.go
new file mode 100644
index 00000000000..1030a98883a
--- /dev/null
+++ b/system_tests/espresso/chain/siphon_blocks_test.go
@@ -0,0 +1,76 @@
+package chain_test
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"fmt"
+	"testing"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+	espresso_common "github.com/EspressoSystems/espresso-network/sdks/go/types/common"
+
+	"github.com/offchainlabs/nitro/system_tests/espresso/chain"
+)
+
+// generatePayloadOfSize generates a transaction payload with random data
+// of the specified size.
+func generatePayloadOfSize(size int) espresso_common.Transaction {
+	bytes := make([]byte, size)
+	_, err := rand.Read(bytes)
+	if err != nil {
+		panic(fmt.Sprintf("failed to generate random bytes: %v", err))
+	}
+
+	return espresso_common.Transaction{
+		Payload: bytes,
+	}
+}
+
+// TestSiphonBlocksWithTransactions tests the SiphonBlocksWithTransactions
+// wrapper around the Espresso client, ensuring that it correctly fetches
+// transactions in blocks and sends them to a channel.
+func TestSiphonBlocksWithTransactions(t *testing.T) {
+	ch := make(chan espresso_client.TransactionsInBlock, 1)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	mockClient := chain.NewMockEspressoChain()
+	siphonClient := chain.NewSiphonBlocksWithTransactions(mockClient, ch)
+
+	tx := generatePayloadOfSize(5_000)
+
+	txnHash, err := mockClient.SubmitTransaction(ctx, generatePayloadOfSize(5_000))
+	if err != nil {
+		t.Fatalf("expected no error submitting transaction 1:have:\n\t%v", err)
+	}
+
+	mockClient.Advance()
+
+	transactionDetails, err := siphonClient.FetchTransactionByHash(ctx, txnHash)
+	if err != nil {
+		t.Fatalf("expected no error fetching transaction by hash:have:\n\t%v", err)
+	}
+
+	// Fetch transactions in block
+	_, err = siphonClient.FetchTransactionsInBlock(ctx, transactionDetails.BlockHeight, tx.Namespace)
+	if err != nil {
+		t.Fatalf("expected no error fetching transactions in block:have:\n\t%v", err)
+	}
+
+	// Check if the transaction details were sent to the channel
+	select {
+	default:
+		t.Fatal("expected to receive transaction details from channel, but got none")
+
+	case result := <-ch:
+		if have, want := len(result.Transactions), 1; have != want {
+			t.Fatalf("expected the number of transactions in the block to match the expectation:\nhave:\n\t%v\nwant:\n\t%v", have, want)
+		}
+
+		txnZero := result.Transactions[0]
+
+		if have, want := txnZero, tx.Payload; bytes.Equal(have, want) {
+			t.Fatalf("expected transaction payload to match:\nhave:\n\t%x\nwant:\n\t%x", have, want)
+		}
+	}
+}
diff --git a/system_tests/espresso/chain/timing.go b/system_tests/espresso/chain/timing.go
new file mode 100644
index 00000000000..12bb15b364b
--- /dev/null
+++ b/system_tests/espresso/chain/timing.go
@@ -0,0 +1,23 @@
+package chain
+
+import (
+	"time"
+)
+
+// TimingData holds the timing information for a generic timeline entry.
+// It includes the duration of the event as well as the start and end times.
+type TimingData struct {
+	Duration time.Duration
+	Start    time.Time
+	End      time.Time
+}
+
+// Timing creates a new TimingData instance with the duration between start
+// and end times.
+func Timing(start, end time.Time) TimingData {
+	return TimingData{
+		Duration: end.Sub(start),
+		Start:    start,
+		End:      end,
+	}
+}
diff --git a/system_tests/espresso/chain/timing_test.go b/system_tests/espresso/chain/timing_test.go
new file mode 100644
index 00000000000..17cbf3a14e3
--- /dev/null
+++ b/system_tests/espresso/chain/timing_test.go
@@ -0,0 +1,31 @@
+package chain_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/offchainlabs/nitro/system_tests/espresso/chain"
+)
+
+// TestTiming tests the Timing function to ensure it correctly calculates
+// the duration between start and end times, and that it captures the start
+// and end times accurately.
+func TestTiming(t *testing.T) {
+	start := time.Now()
+	time.Sleep(100 * time.Millisecond)
+	end := time.Now()
+
+	timingData := chain.Timing(start, end)
+
+	if have, want := timingData.Duration, 100*time.Millisecond; have <= want {
+		t.Errorf("process should have slept for at least the expected duration:\nhave:\n\t%q\nwant:\n\t%q", have, want)
+	}
+
+	if have, want := timingData.Start, start; have != want {
+		t.Errorf("start time should match expectation:\nhave:\n\t%q\nwant:\n\t%q", have, want)
+	}
+
+	if have, want := timingData.End, end; have != want {
+		t.Errorf("end time should match expectation:\nhave:\n\t%q\nwant:\n\t%q", have, want)
+	}
+}
diff --git a/system_tests/espresso/chain/unimplemented_espresso_client.go b/system_tests/espresso/chain/unimplemented_espresso_client.go
new file mode 100644
index 00000000000..1534c882ff3
--- /dev/null
+++ b/system_tests/espresso/chain/unimplemented_espresso_client.go
@@ -0,0 +1,96 @@
+package chain
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+	"github.com/EspressoSystems/espresso-network/sdks/go/types"
+	"github.com/EspressoSystems/espresso-network/sdks/go/types/common"
+)
+
+// ErrorEspressoClientUnimplementedMethod is an error type that indicates tha
+//
+//	an Espresso client method is unimplemented.
+type ErrorEspressoClientUnimplementedMethod struct {
+	Method string
+}
+
+// Error implements error
+func (e ErrorEspressoClientUnimplementedMethod) Error() string {
+	return fmt.Sprintf("unimplemented espresso client method: %s", e.Method)
+}
+
+// UnimplementedEspressoClient is an implementation of
+// espresso_client.EspressoClient with all methods resulting in a panic
+// on invocation.
+//
+// This is useful, as it allows future implementors to create simpler
+// mocks by falling back on this implementation, rather than
+// implementing all methods of the interface.
+type UnimplementedEspressoClient struct{}
+
+// FetchNamespaceTransactionsInRange implements client.EspressoClient.
+func (u UnimplementedEspressoClient) FetchNamespaceTransactionsInRange(ctx context.Context, namespace uint64, fromHeight uint64, toHeight uint64) ([]types.NamespaceTransactionsRangeData, error) {
+	panic("unimplemented")
+}
+
+// StreamTransactions implements client.EspressoClient.
+func (u UnimplementedEspressoClient) StreamTransactions(ctx context.Context, height uint64) (espresso_client.Stream[types.TransactionQueryData], error) {
+	panic("unimplemented")
+}
+
+// StreamTransactionsInNamespace implements client.EspressoClient.
+func (u UnimplementedEspressoClient) StreamTransactionsInNamespace(ctx context.Context, height uint64, namespace uint64) (espresso_client.Stream[types.TransactionQueryData], error) {
+	panic("unimplemented")
+}
+
+// Compile time check to ensure that UnimplementedEspressoClient implements
+// espresso_client.EspressoClient.
+var _ espresso_client.EspressoClient = UnimplementedEspressoClient{}
+
+// FetchHeaderByHeight implements client.EspressoClient.
+func (UnimplementedEspressoClient) FetchHeaderByHeight(ctx context.Context, height uint64) (types.HeaderImpl, error) {
+	panic(ErrorEspressoClientUnimplementedMethod{"FetchHeaderByHeight"})
+}
+
+// FetchHeadersByRange implements client.EspressoClient.
+func (UnimplementedEspressoClient) FetchHeadersByRange(ctx context.Context, from uint64, until uint64) ([]types.HeaderImpl, error) {
+	panic(ErrorEspressoClientUnimplementedMethod{"FetchHeadersByRange"})
+}
+
+// FetchLatestBlockHeight implements client.EspressoClient.
+func (UnimplementedEspressoClient) FetchLatestBlockHeight(ctx context.Context) (uint64, error) {
+	panic(ErrorEspressoClientUnimplementedMethod{"FetchLatestBlockHeight"})
+}
+
+// FetchRawHeaderByHeight implements client.EspressoClient.
+func (UnimplementedEspressoClient) FetchRawHeaderByHeight(ctx context.Context, height uint64) (json.RawMessage, error) {
+	panic(ErrorEspressoClientUnimplementedMethod{"FetchRawHeaderByHeight"})
+}
+
+// FetchTransactionByHash implements client.EspressoClient.
+func (UnimplementedEspressoClient) FetchTransactionByHash(ctx context.Context, hash *types.TaggedBase64) (types.TransactionQueryData, error) {
+	panic(ErrorEspressoClientUnimplementedMethod{"FetchTransactionByHash"})
+}
+
+// FetchTransactionsInBlock implements client.EspressoClient.
+func (UnimplementedEspressoClient) FetchTransactionsInBlock(ctx context.Context, blockHeight uint64, namespace uint64) (espresso_client.TransactionsInBlock, error) {
+	panic(ErrorEspressoClientUnimplementedMethod{"FetchTransactionsInBlock"})
+}
+
+// FetchVidCommonByHeight implements client.EspressoClient.
+func (UnimplementedEspressoClient) FetchVidCommonByHeight(ctx context.Context, blockHeight uint64) (types.VidCommon, error) {
+	panic(ErrorEspressoClientUnimplementedMethod{"FetchVidCommonByHeight"})
+}
+
+// SubmitTransaction implements client.EspressoClient.
+func (UnimplementedEspressoClient) SubmitTransaction(ctx context.Context, tx common.Transaction) (*common.TaggedBase64, error) {
+	panic(ErrorEspressoClientUnimplementedMethod{"SubmitTransaction"})
+}
+
+// FetchExplorerTransactionByHash implements client.EspressoClient.
+func (UnimplementedEspressoClient) FetchExplorerTransactionByHash(ctx context.Context, hash *types.TaggedBase64) (types.ExplorerTransactionQueryData, error) {
+	panic(ErrorEspressoClientUnimplementedMethod{"FetchExplorerTransactionByHash"})
+}
diff --git a/system_tests/espresso/chain/unimplemented_espresso_client_test.go b/system_tests/espresso/chain/unimplemented_espresso_client_test.go
new file mode 100644
index 00000000000..2f1071f68bc
--- /dev/null
+++ b/system_tests/espresso/chain/unimplemented_espresso_client_test.go
@@ -0,0 +1,111 @@
+package chain_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	espresso_common "github.com/EspressoSystems/espresso-network/sdks/go/types/common"
+
+	"github.com/offchainlabs/nitro/system_tests/espresso/chain"
+)
+
+// expectPanicWithErrorLightClientUnimplementedMethod is a helper function that
+// expects a panic to occur when the provided function is called.
+//
+// It checks that the panic is of type chain.ErrorEspressoClientUnimplementedMethod
+// and that the method name matches the expected method name.
+func expectPanicWithErrorEspressoClientUnimplementedMethod(t *testing.T, fn func(), methodName string) {
+	defer func() {
+		err := recover()
+		if have, want := err, (any)(nil); have == want {
+			t.Errorf("expected recover to recover from panic:\nhave:\n\t\"%v\"\ndo not want:\n\t\"%v\"", have, want)
+			return
+		}
+
+		cast, castOk := err.(chain.ErrorEspressoClientUnimplementedMethod)
+
+		if have, want := castOk, true; have != want {
+			t.Errorf("expected cast to be chain.ErrorEspressoClientUnimplementedMethod:\nhave:\n\t\"%v\"\nwant:\n\t\"%v\"", have, want)
+			return
+		}
+
+		if have, want := cast.Method, methodName; have != want {
+			t.Errorf("expected method name to match:\nhave:\n\t\"%v\"\nwant:\n\t\"%v\"", have, want)
+			return
+		}
+	}()
+
+	fn()
+}
+
+// TestUnimplementedExecutionClient tests the UnimplementedEspressoClient
+// to ensure that it panics when any of its methods are called.
+func TestUnimplementedExecutionClient(t *testing.T) {
+	var client chain.UnimplementedEspressoClient
+
+	t.Run("FetchHeaderByHeight", func(t *testing.T) {
+		expectPanicWithErrorEspressoClientUnimplementedMethod(t, func() {
+			_, _ = client.FetchHeaderByHeight(context.Background(), 0)
+		}, "FetchHeaderByHeight")
+	})
+
+	t.Run("FetchHeadersByRange", func(t *testing.T) {
+		expectPanicWithErrorEspressoClientUnimplementedMethod(t, func() {
+			_, _ = client.FetchHeadersByRange(context.Background(), 0, 1)
+		}, "FetchHeadersByRange")
+	})
+
+	t.Run("FetchLatestBlockHeight", func(t *testing.T) {
+		expectPanicWithErrorEspressoClientUnimplementedMethod(t, func() {
+			_, _ = client.FetchLatestBlockHeight(context.Background())
+		}, "FetchLatestBlockHeight")
+	})
+
+	t.Run("FetchRawHeaderByHeight", func(t *testing.T) {
+		expectPanicWithErrorEspressoClientUnimplementedMethod(t, func() {
+			_, _ = client.FetchRawHeaderByHeight(context.Background(), 0)
+		}, "FetchRawHeaderByHeight")
+	})
+
+	t.Run("FetchTransactionByHash", func(t *testing.T) {
+		expectPanicWithErrorEspressoClientUnimplementedMethod(t, func() {
+			_, _ = client.FetchTransactionByHash(context.Background(), nil)
+		}, "FetchTransactionByHash")
+	})
+
+	t.Run("FetchTransactionsInBlock", func(t *testing.T) {
+		expectPanicWithErrorEspressoClientUnimplementedMethod(t, func() {
+			_, _ = client.FetchTransactionsInBlock(context.Background(), 0, 0)
+		}, "FetchTransactionsInBlock")
+	})
+
+	t.Run("FetchVidCommonByHeight", func(t *testing.T) {
+		expectPanicWithErrorEspressoClientUnimplementedMethod(t, func() {
+			_, _ = client.FetchVidCommonByHeight(context.Background(), 0)
+		}, "FetchVidCommonByHeight")
+	})
+
+	t.Run("SubmitTransaction", func(t *testing.T) {
+		expectPanicWithErrorEspressoClientUnimplementedMethod(t, func() {
+			_, _ = client.SubmitTransaction(context.Background(), espresso_common.Transaction{})
+		}, "SubmitTransaction")
+	})
+
+	t.Run("FetchExplorerTransactionByHash", func(t *testing.T) {
+		expectPanicWithErrorEspressoClientUnimplementedMethod(t, func() {
+			_, _ = client.FetchExplorerTransactionByHash(context.Background(), nil)
+		}, "FetchExplorerTransactionByHash")
+	})
+}
+
+// ExampleErrorEspressoClientUnimplementedMethod demonstrates how to use the
+// ErrorEspressoClientUnimplementedMethod error type.
+func ExampleErrorEspressoClientUnimplementedMethod() {
+	err := chain.ErrorEspressoClientUnimplementedMethod{
+		Method: "Hello",
+	}
+
+	fmt.Printf("Error: %s\n", err.Error())
+	// Output: Error: unimplemented espresso client method: Hello
+}
diff --git a/system_tests/espresso/config/espresso_config_parsing_test.go b/system_tests/espresso/config/espresso_config_parsing_test.go
new file mode 100644
index 00000000000..2de32e97d61
--- /dev/null
+++ b/system_tests/espresso/config/espresso_config_parsing_test.go
@@ -0,0 +1,94 @@
+package config_test
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/knadh/koanf"
+	"github.com/knadh/koanf/parsers/json"
+	"github.com/knadh/koanf/providers/confmap"
+	"github.com/knadh/koanf/providers/rawbytes"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/offchainlabs/nitro/arbnode"
+)
+
+func TestEspressoConfigParsing(t *testing.T) {
+	inputSource := map[string]interface{}{
+		"sequencer": true,
+		"espresso": map[string]interface{}{
+			"caff-node": map[string]interface{}{
+				"enable": true,
+			},
+			"batch-poster": map[string]interface{}{
+				"tee-type":    "NITRO",
+				"hotshot-url": "http://localhost:8080",
+			},
+			"streamer": map[string]interface{}{
+				"hotshot-block":         uint64(100),
+				"txns-polling-interval": "3s",
+				"address-monitor-step":  uint64(100),
+			},
+		},
+	}
+
+	k := koanf.New(".")
+	err := k.Load(confmap.Provider(inputSource, "."), nil)
+	require.NoError(t, err)
+
+	var parsedConfig arbnode.Config
+	err = k.UnmarshalWithConf("", &parsedConfig, koanf.UnmarshalConf{Tag: "koanf"})
+	require.NoError(t, err)
+
+	assert.Equal(t, true, parsedConfig.Sequencer)
+	assert.Equal(t, true, parsedConfig.Espresso.CaffNode.Enable)
+	assert.Equal(t, "NITRO", parsedConfig.Espresso.BatchPoster.TeeType)
+	assert.Equal(t, "http://localhost:8080", parsedConfig.Espresso.BatchPoster.HotShotUrl)
+	assert.Equal(t, uint64(100), parsedConfig.Espresso.Streamer.HotShotBlock)
+	assert.Equal(t, 3*time.Second, parsedConfig.Espresso.Streamer.TxnsPollingInterval)
+	assert.Equal(t, uint64(100), parsedConfig.Espresso.Streamer.AddressMonitorStep)
+}
+
+func TestEspressoConfigMigration(t *testing.T) {
+	const oldConfigJSONPath = "./testdata/migrated_config.json"
+
+	oldConfigJSON, err := os.ReadFile(oldConfigJSONPath)
+	require.NoError(t, err)
+
+	k := koanf.New(".")
+
+	err = k.Load(
+		rawbytes.Provider([]byte(oldConfigJSON)),
+		json.Parser(),
+	)
+	require.NoError(t, err)
+
+	var cfg arbnode.Config
+	err = k.Unmarshal("", &cfg)
+	require.NoError(t, err)
+
+	// streamer
+	require.Equal(t, uint64(10), cfg.Espresso.Streamer.HotShotBlock)
+
+	// caff-node
+	require.True(
+		t,
+		cfg.Espresso.CaffNode.Dangerous.IgnoreDatabaseHotshotBlock,
+	)
+	require.False(
+		t,
+		cfg.Espresso.CaffNode.Dangerous.IgnoreDatabaseFromBlock,
+	)
+
+	require.Equal(t,
+		time.Duration(2*time.Second),
+		cfg.Espresso.Streamer.TxnsPollingInterval,
+	)
+
+	require.Equal(t,
+		uint64(100),
+		cfg.Espresso.Streamer.AddressMonitorStep,
+	)
+}
diff --git a/system_tests/espresso/config/testdata/migrated_config.json b/system_tests/espresso/config/testdata/migrated_config.json
new file mode 100644
index 00000000000..6c08db448e9
--- /dev/null
+++ b/system_tests/espresso/config/testdata/migrated_config.json
@@ -0,0 +1,161 @@
+{
+  "chain": {
+    "info-files": [
+      "/config/l2_chain_info.json"
+    ]
+  },
+  "espresso": {
+    "batch-poster": {
+      "address-valid-ranges": [
+        {
+          "address": "${address1}",
+          "from": 1,
+          "to": 99
+        },
+        {
+          "address": "${address2}",
+          "from": 99,
+          "to": 199
+        }
+      ],
+      "hotshot-first-posting-block": 1,
+      "hotshot-url": "https://localhost:9090",
+      "register-service-config": {
+        "max-base-fee": 10,
+        "max-retries": 5
+      },
+      "resubmit-espresso-tx-deadline": "2m",
+      "tee-type": "${espresso_tee_type}"
+    },
+    "caff-node": {
+      "dangerous": {
+        "ignore-database-from-block": false,
+        "ignore-database-hotshot-block": true
+      },
+      "enable": false,
+      "from-block": 5,
+      "namespace": 23,
+      "tee-type": "${espresso_tee_type}"
+    },
+    "streamer": {
+      "address-monitor-start-l1": 1,
+      "address-monitor-step": 100,
+      "dangerous": {
+        "minimum-hotshot-block-num": 56
+      },
+      "hotshot-block": 10,
+      "txns-polling-interval": "2s"
+    }
+  },
+  "execution": {
+    "forwarding-target": "null",
+    "sequencer": {
+      "enable": true
+    }
+  },
+  "http": {
+    "addr": "0.0.0.0",
+    "api": [
+      "eth",
+      "net",
+      "web3",
+      "arb",
+      "debug",
+      "txpool"
+    ],
+    "corsdomain": "*",
+    "vhosts": "*"
+  },
+  "node": {
+    "batch-poster": {
+      "data-poster": {
+        "max-base-fee": 10
+      },
+      "enable": true,
+      "l1-block-bound": "ignore",
+      "light-client-address": "${light_client_address}",
+      "max-delay": "1h0m0s",
+      "max-empty-batch-delay": "1h0m0s",
+      "parent-chain-wallet": {
+        "private-key": "${batch_poster_secret_arn}"
+      },
+      "poll-interval": "10s",
+      "post-4844-blobs": false,
+      "redis-url": "",
+      "wait-for-max-delay": true
+    },
+    "block-validator": {
+      "enable": true,
+      "validation-server": {
+        "jwtsecret": "/config/val_jwt.hex",
+        "url": "${validation_server_url}"
+      }
+    },
+    "dangerous": {
+      "disable-blob-reader": true,
+      "no-sequencer-coordinator": true
+    },
+    "data-availability": {
+      "enable": false
+    },
+    "delayed-sequencer": {
+      "enable": true,
+      "finalize-distance": 6,
+      "use-merge-finality": false
+    },
+    "feed": {
+      "input": {
+        "url": ""
+      },
+      "output": {
+        "enable": true,
+        "signed": false
+      }
+    },
+    "parent-chain-reader": {
+      "poll-interval": "60s",
+      "poll-only": true
+    },
+    "seq-coordinator": {
+      "enable": false,
+      "lockout-duration": "30s",
+      "lockout-spare": "1s",
+      "my-url": "",
+      "redis-url": "redis://redis:6379",
+      "retry-interval": "0.5s",
+      "seq-num-duration": "24h0m0s",
+      "update-interval": "3s"
+    },
+    "sequencer": true,
+    "staker": {
+      "disable-challenge": false,
+      "enable": true,
+      "make-assertion-interval": "120s",
+      "parent-chain-wallet": {
+        "private-key": "${staker_secret_arn}"
+      },
+      "staker-interval": "120s",
+      "strategy": "MakeNodes"
+    }
+  },
+  "parent-chain": {
+    "connection": {
+      "url": "${parent_chain_url_secret_arn}"
+    }
+  },
+  "persistent": {
+    "chain": "local",
+    "db-engine": "leveldb"
+  },
+  "ws": {
+    "addr": "0.0.0.0",
+    "api": [
+      "eth",
+      "net",
+      "web3",
+      "arb",
+      "debug",
+      "txpool"
+    ]
+  }
+}
\ No newline at end of file
diff --git a/system_tests/espresso/espresso_transaction_streamer_throughput_test.go b/system_tests/espresso/espresso_transaction_streamer_throughput_test.go
new file mode 100644
index 00000000000..e925825b30f
--- /dev/null
+++ b/system_tests/espresso/espresso_transaction_streamer_throughput_test.go
@@ -0,0 +1,494 @@
+package espresso_test
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"testing"
+	"time"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/offchainlabs/nitro/arbnode"
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+	"github.com/offchainlabs/nitro/espresso/submitter"
+	"github.com/offchainlabs/nitro/system_tests/espresso/chain"
+	execution_engine "github.com/offchainlabs/nitro/system_tests/espresso/execution_engine"
+	generate "github.com/offchainlabs/nitro/system_tests/espresso/generate"
+	transaction_streamer "github.com/offchainlabs/nitro/system_tests/espresso/transaction_streamer"
+)
+
+// RunChains sets up the Espresso chain and the TransactionStreamer,
+// producing messages at a specified interval. It simulates the sequencer
+// sending messages to the TransactionStreamer.
+// It also simulates the Espresso chain producing blocks at a specified interval.
+func RunChains(ctx context.Context, t *testing.T, mockEspressoChain *chain.MockEspressoChain, streamer *arbnode.TransactionStreamer, behaviors ...generate.GenerationBehavior) {
+	messagesInChannel := make(chan generate.Message, 10)
+	// Produce Espresso Blocks at a 2 second interval
+	go chain.ProduceEspressoBlocksAtInterval(ctx, mockEspressoChain, 2*time.Second)
+
+	// Produce the messages in the channel, so that the TransactionStreamer can
+	// process them.
+	go generate.ProduceMessages(
+		ctx,
+		execution_engine.DefaultMessageHasher,
+		messagesInChannel,
+		behaviors...,
+	)
+
+	// Start sending transactions to the TransactionStreamer at a specified
+	// interval. This simulates the sequencer sending messages to the
+	// TransactionStreamer.
+	go (func() {
+		_ = generate.SendMessageToWriter(ctx, streamer, messagesInChannel)
+	})()
+}
+
+func WithWorkerQueueSubmitter() transaction_streamer.MockTransactionStreamerEnvironmentOption {
+	return transaction_streamer.WithEspressoTransactionStreamerOptions(
+		arbnode.WithSubmitterCreator(submitter.NewMultiWorkerQueueEspressoSubmitter),
+	)
+}
+
+// numeric is a type constraint that allows any numeric type, including
+// integers and floating-point numbers.
+type numeric interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~float32 | ~float64
+}
+
+// expected is a generic type that holds an expected value and an epsilon
+// value for comparison. It provides methods to check if an actual value is
+// within the expected range.
+type expected[T numeric] struct {
+	value   T
+	epsilon T
+}
+
+// IsWithinEpsilon checks if the actual value is within the range of
+// expected value ± epsilon.
+func (e expected[T]) IsWithinEpsilon(actual T) bool {
+	return actual >= e.value-e.epsilon && actual <= e.value+e.epsilon
+}
+
+// IsLessThanOrEqualTo checks if the actual value is less than or equal to
+// the expected value plus epsilon.
+func (e expected[T]) IsLessThanOrEqualTo(actual T) bool {
+	return actual <= e.value+e.epsilon
+}
+
+// IsGreaterThanOrEqualTo checks if the actual value is greater than or equal to
+// the expected value minus epsilon.
+func (e expected[T]) IsGreaterThanOrEqualTo(actual T) bool {
+	return actual >= e.value-e.epsilon
+}
+
+func (e expected[T]) String() string {
+	return fmt.Sprintf("%v (± %v)", e.value, e.epsilon)
+}
+
+// scenario defines a test scenario for the TransactionStreamer Espresso
+// throughput test.
+type scenario struct {
+	name string
+
+	// Test Setup
+	samples         int
+	streamerOptions []transaction_streamer.MockTransactionStreamerEnvironmentOption
+	behaviors       []generate.GenerationBehavior
+
+	// Test Acceptance
+	duration          expected[time.Duration]
+	messageThroughput expected[float64]
+	sizeThroughput    expected[float64]
+}
+
+// TestEspressoRegressionTransactionStreamerToEspressoThroughput is a test that setups
+// and times a simplified interaction setup between the TransactionStreamer
+// and the Espresso chain.
+//
+// The purpose of this test is to setup the mock environment, and measure the
+// performance throughput of the Environment based on the actual implementation
+// of the Espresso communication present within the TransactionStreamer.
+func TestEspressoRegressionTransactionStreamerToEspressoThroughput(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	scenarios := []scenario{
+		// Molten scenario
+		// Generate 500 messages as 4 message/s each sized as 3KiB
+		// Idealized Builder
+		//
+		// Expect the throughput to roughly be 4 messages/s and 12KiB/s
+		{
+			name:    "MoltenStandardThroughputIdealizedBuilderPollingSubmitter",
+			samples: 500,
+			behaviors: []generate.GenerationBehavior{
+				generate.GenerateStandardMoltenMessages(500),
+			},
+
+			duration: expected[time.Duration]{
+				value:   2*time.Minute + 30*time.Second, // 2m30s
+				epsilon: 30 * time.Second,               // 30s tolerance
+			},
+			messageThroughput: expected[float64]{
+				value:   4,   // 4 messages/s
+				epsilon: 0.2, // 0.2 message/s tolerance
+			},
+			sizeThroughput: expected[float64]{
+				value:   4 * generate.DefaultMoltenMessageSize, // 4 messages/s * 3KiB per message
+				epsilon: 512,                                   // 512 bytes tolerance
+			},
+		},
+
+		// Molten scenario
+		// Generate 500 messages as 4 message/s each sized as 3KiB
+		// Builder with Max Size of 1MiB
+		//
+		// Expect the throughput to roughly be 4 messages/s and 12KiB/s
+		{
+			name:    "MoltenStandardThroughput1MiBBuilderPollingSubmitter",
+			samples: 500,
+			streamerOptions: []transaction_streamer.MockTransactionStreamerEnvironmentOption{
+				transaction_streamer.AddChainOptions(
+					// 1MiB
+					chain.WithBuilder(chain.NewMaxSizeRestrictedBuilder(1024 * 1024)),
+				),
+			},
+
+			behaviors: []generate.GenerationBehavior{
+				generate.GenerateStandardMoltenMessages(500),
+			},
+
+			duration: expected[time.Duration]{
+				value:   6*time.Minute + 30*time.Second, // 6m30s
+				epsilon: 30 * time.Second,               // 30s tolerance
+			},
+			messageThroughput: expected[float64]{
+				value:   4,   // 4 messages/s
+				epsilon: 0.2, // 0.2 message/s tolerance
+			},
+			sizeThroughput: expected[float64]{
+				value:   4 * generate.DefaultMoltenMessageSize, // 4 messages/s * 3KiB per message
+				epsilon: 512,                                   // 512 bytes tolerance
+			},
+		},
+
+		// Molten Scenario
+		// Backlog generate 1_000 messages as quickly as possible each sized as 3KiB
+		// Idealized Builder
+		//
+		// Expect the throughput to allow us to catch up at a significant rate.
+		// We expect to be able to process at at least 8x the rate of the
+		// standard throughput, so we expect to see 32 messages/s and 96KiB/s
+		// throughput.
+		//
+		// NOTE: current observed throughput depends on hardware.  But on
+		// a 2023 Macbook Pro with an M3 Pro we observe a throughput of the
+		// following:
+		// Took 7.576660458s for 1,000 messages. A Throughput of 131.98 messages/s
+		// and 305,442.56 bytes/s.
+		{
+			name:    "MoltenPreloadBacklogIdealizedBuilderPollingSubmitter",
+			samples: 1_000,
+			behaviors: []generate.GenerationBehavior{
+				generate.PreloadMoltenMessages(1_000),
+			},
+			duration: expected[time.Duration]{
+				value:   30 * time.Second, // 30s
+				epsilon: 1 * time.Second,  // 1s tolerance
+			},
+			messageThroughput: expected[float64]{
+				value:   32,   // 32 messages/s
+				epsilon: 0.05, // 0.05 message/s tolerance
+			},
+			sizeThroughput: expected[float64]{
+				value:   32 * generate.DefaultMoltenMessageSize, // 32 messages/s * 3KiB per message
+				epsilon: 128,                                    // 128 bytes tolerance
+			},
+		},
+
+		// Molten Scenario
+		// Backlog generate 1_000 messages as quickly as possible each sized as 3KiB
+		// Builder with Max Size of 1MiB
+		// Expect the throughput to allow us to catch up at a significant rate.
+		//
+		// We expect to be able to process at at least 8x the rate of the
+		// standard throughput, so we expect to see 32 messages/s and 96KiB/s
+		// throughput.
+		// This is because the Builder is able to handle the backlog of messages
+		// without being restricted by the size of the Builder.
+		//
+		// NOTE: current observed throughput depends on hardware.  But on
+		// a 2023 Macbook Pro with an M3 Pro we observe a throughput
+		// of the following:
+		// Took 4m12.588955167s for 1,000 messages. A throughput of 90.09 messages/s
+		// and 276,756.48 bytes/s.
+		{
+			name:    "MoltenPreloadBacklog1MiBBuilderPollingSubmitter",
+			samples: 1_000,
+			streamerOptions: []transaction_streamer.MockTransactionStreamerEnvironmentOption{
+				transaction_streamer.AddChainOptions(
+					// 1MiB
+					chain.WithBuilder(chain.NewMaxSizeRestrictedBuilder(1024 * 1024)),
+				),
+			},
+			behaviors: []generate.GenerationBehavior{
+				generate.PreloadMoltenMessages(1_000),
+			},
+			duration: expected[time.Duration]{
+				value:   30 * time.Second, // 30s
+				epsilon: 1 * time.Second,  // 1s tolerance
+			},
+			messageThroughput: expected[float64]{
+				value:   32,   // 32 messages/s
+				epsilon: 0.05, // 0.05 message/s tolerance
+			},
+			sizeThroughput: expected[float64]{
+				value:   32 * generate.DefaultMoltenMessageSize, // 32 messages/s * 3KiB per message
+				epsilon: 128,                                    // 128 bytes tolerance
+			},
+		},
+
+		// Molten scenario
+		// Generate 500 messages as 4 message/s each sized as 3KiB
+		// Idealized Builder
+		//
+		// Expect the throughput to roughly be 4 messages/s and 12KiB/s
+		{
+			name:    "MoltenStandardThroughputIdealizedBuilderWorkersSubmitter",
+			samples: 500,
+			streamerOptions: []transaction_streamer.MockTransactionStreamerEnvironmentOption{
+				WithWorkerQueueSubmitter(),
+			},
+			behaviors: []generate.GenerationBehavior{
+				generate.GenerateStandardMoltenMessages(500),
+			},
+
+			duration: expected[time.Duration]{
+				value:   2*time.Minute + 30*time.Second, // 2m30s
+				epsilon: 30 * time.Second,               // 30s tolerance
+			},
+			messageThroughput: expected[float64]{
+				value:   4,   // 4 messages/s
+				epsilon: 0.2, // 0.2 message/s tolerance
+			},
+			sizeThroughput: expected[float64]{
+				value:   4 * generate.DefaultMoltenMessageSize, // 4 messages/s * 3KiB per message
+				epsilon: 512,                                   // 512 bytes tolerance
+			},
+		},
+
+		// Molten scenario
+		// Generate 500 messages as 4 message/s each sized as 3KiB
+		// Builder with Max Size of 1MiB
+		//
+		// Expect the throughput to roughly be 4 messages/s and 12KiB/s
+		{
+			name:    "MoltenStandardThroughput1MiBBuilderWorkersSubmitter",
+			samples: 500,
+			streamerOptions: []transaction_streamer.MockTransactionStreamerEnvironmentOption{
+				WithWorkerQueueSubmitter(),
+				transaction_streamer.AddChainOptions(
+					// 1MiB
+					chain.WithBuilder(chain.NewMaxSizeRestrictedBuilder(1024 * 1024)),
+				),
+			},
+
+			behaviors: []generate.GenerationBehavior{
+				generate.GenerateStandardMoltenMessages(500),
+			},
+
+			duration: expected[time.Duration]{
+				value:   2*time.Minute + 30*time.Second, // 6m30s
+				epsilon: 30 * time.Second,               // 30s tolerance
+			},
+			messageThroughput: expected[float64]{
+				value:   4,   // 4 messages/s
+				epsilon: 0.2, // 0.2 message/s tolerance
+			},
+			sizeThroughput: expected[float64]{
+				value:   4 * generate.DefaultMoltenMessageSize, // 4 messages/s * 3KiB per message
+				epsilon: 512,                                   // 512 bytes tolerance
+			},
+		},
+
+		// Molten Scenario
+		// Backlog generate 1_000 messages as quickly as possible each sized as 3KiB
+		// Idealized Builder
+		//
+		// Expect the throughput to allow us to catch up at a significant rate.
+		// We expect to be able to process at at least 8x the rate of the
+		// standard throughput, so we expect to see 32 messages/s and 96KiB/s
+		// throughput.
+		//
+		// NOTE: current observed throughput depends on hardware.  But on
+		// a 2023 Macbook Pro with an M3 Pro we observe a throughput of the
+		// following:
+		// Took 7.576660458s for 1,000 messages. A Throughput of 131.98 messages/s
+		// and 305,442.56 bytes/s.
+		{
+			name:    "MoltenPreloadBacklogIdealizedBuilderWorkersSubmitter",
+			samples: 1_000,
+			streamerOptions: []transaction_streamer.MockTransactionStreamerEnvironmentOption{
+				WithWorkerQueueSubmitter(),
+			},
+			behaviors: []generate.GenerationBehavior{
+				generate.PreloadMoltenMessages(1_000),
+			},
+			duration: expected[time.Duration]{
+				value:   4 * time.Second, // 4s
+				epsilon: 1 * time.Second, // 1s tolerance
+			},
+			messageThroughput: expected[float64]{
+				value:   100,  // 100 messages/s
+				epsilon: 0.05, // 0.05 message/s tolerance
+			},
+			sizeThroughput: expected[float64]{
+				value:   100 * generate.DefaultMoltenMessageSize, // 100 messages/s * 3KiB per message
+				epsilon: 128,                                     // 128 bytes tolerance
+			},
+		},
+
+		// Molten Scenario
+		// Backlog generate 1_000 messages as quickly as possible each sized as 3KiB
+		// Builder with Max Size of 1MiB
+		// Expect the throughput to allow us to catch up at a significant rate.
+		//
+		// We expect to be able to process at at least 8x the rate of the
+		// standard throughput, so we expect to see 32 messages/s and 96KiB/s
+		// throughput.
+		// This is because the Builder is able to handle the backlog of messages
+		// without being restricted by the size of the Builder.
+		//
+		// NOTE: current observed throughput depends on hardware.  But on
+		// a 2023 Macbook Pro with an M3 Pro we observe a throughput
+		// of the following:
+		// Took 4m12.588955167s for 1,000 messages. A throughput of 90.09 messages/s
+		// and 276,756.48 bytes/s.
+		{
+			name:    "MoltenPreloadBacklog1MiBBuilderWorkersSubmitter",
+			samples: 1_000,
+			streamerOptions: []transaction_streamer.MockTransactionStreamerEnvironmentOption{
+				WithWorkerQueueSubmitter(),
+				transaction_streamer.AddChainOptions(
+					// 1MiB
+					chain.WithBuilder(chain.NewMaxSizeRestrictedBuilder(1024 * 1024)),
+				),
+			},
+			behaviors: []generate.GenerationBehavior{
+				generate.PreloadMoltenMessages(1_000),
+			},
+			duration: expected[time.Duration]{
+				value:   10 * time.Second, // 10s
+				epsilon: 1 * time.Second,  // 1s tolerance
+			},
+			messageThroughput: expected[float64]{
+				value:   80,   // 80 messages/s
+				epsilon: 0.05, // 0.05 message/s tolerance
+			},
+			sizeThroughput: expected[float64]{
+				value:   80 * generate.DefaultMoltenMessageSize, // 80 messages/s * 3KiB per message
+				epsilon: 128,                                    // 128 bytes tolerance
+			},
+		},
+	}
+
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			// Setup the context for the test
+			scenarioCtx, scenarioCancel := context.WithCancel(ctx)
+			defer scenarioCancel()
+
+			hasher := execution_engine.DefaultMessageHasher
+
+			// Setup a buffer of GeneratedMessages to be sent to the TransactionStreamer
+			// so we can build up a backlog of messages to be processed.
+			blocksWithTransactionsCh := make(chan espresso_client.TransactionsInBlock, scenario.samples)
+
+			// Setup the mock environment for the TransactionStreamer
+			mockEspressoChain, _, _, streamer, err := transaction_streamer.NewMockTransactionStreamerEnvironment(
+				scenarioCtx,
+				transaction_streamer.AddEspressoClientOptions(
+					func(espressoClient espresso_client.EspressoClient) espresso_client.EspressoClient {
+						return chain.NewEspressoClientSimulatedLatency(espressoClient)
+					},
+					func(espressoClient espresso_client.EspressoClient) espresso_client.EspressoClient {
+						return chain.NewSiphonBlocksWithTransactions(espressoClient, blocksWithTransactionsCh)
+					},
+				),
+				transaction_streamer.WithMultipleMockTransactionStreamerEnvironmentOptions(
+					scenario.streamerOptions...,
+				),
+			)
+
+			if have, want := err, error(nil); !errors.Is(have, want) {
+				t.Fatalf("encountered error while creating mock transaction streamer environment:\nhave:\n\t\"%v\"\nwant:\n\t\"%v\"", have, want)
+			}
+
+			// Run the scenario with the mock environment
+			RunChains(scenarioCtx, t, mockEspressoChain, streamer, scenario.behaviors...)
+
+			start := time.Now()
+			// Start the TransactionStreamer, so that processing begins
+			if have, want := streamer.Start(scenarioCtx), error(nil); !errors.Is(have, want) {
+				t.Fatalf("encountered error while starting TransactionStreamer:\nhave:\n\t\"%v\"\nwant:\n\t\"%v\"", have, want)
+			}
+
+			// Let's grab the messages that are being sent to the TransactionStreamer
+			// and are being processed by the Espresso chain.
+			receivedMessages := make(map[common.Hash]arbostypes.MessageWithMetadata)
+
+			// Let's consume the transactions from the mock espresso chain, until we get all
+			// of the transactions that we sent to the TransactionStreamer.
+			for len(receivedMessages) < scenario.samples {
+				// Read the next transaction
+				blockWithTx := <-blocksWithTransactionsCh
+
+				messages, err := generate.ConvertEspressoTransactionsInBlockToMessages(blockWithTx)
+				if have, want := err, error(nil); !errors.Is(have, want) {
+					t.Fatalf("encountered error while converting transactions in block to messages:\nhave:\n\t\"%v\"\nwant:\n\t\"%v\"", have, want)
+				}
+
+				for _, m := range messages {
+					receivedMessages[hasher.HashMessageWithMetadata(&m)] = m
+				}
+			}
+			end := time.Now()
+
+			// Stop running the TransactionStreamer
+			scenarioCancel()
+			streamer.StopWaiter.StopAndWait()
+
+			timingData := chain.Timing(start, end)
+
+			// Compute the total bytes processed
+			var totalBytesProcessed uint64
+			for _, m := range receivedMessages {
+				totalBytesProcessed += uint64(len(m.Message.L2msg))
+			}
+
+			if have, want := timingData.Duration, scenario.duration; !want.IsLessThanOrEqualTo(have) {
+				t.Errorf("duration is not within expected range:\nhave:\n\t%s\nwant:\n\t<=%s\n",
+					have,
+					want,
+				)
+			}
+
+			if have, want := float64(len(receivedMessages))/timingData.Duration.Seconds(), scenario.messageThroughput; !want.IsGreaterThanOrEqualTo(have) {
+				t.Errorf("message throughput is not within expected range:\nhave:\n\t%.2f messages/s\nwant:\n\t>= %s messages/s\n",
+					have,
+					want,
+				)
+			}
+
+			if have, want := float64(totalBytesProcessed)/timingData.Duration.Seconds(), scenario.sizeThroughput; !want.IsGreaterThanOrEqualTo(have) {
+				t.Errorf("size throughput is not within expected range:\nhave:\n\t%.2f bytes/s\nwant:\n\t>= %s bytes/s\n",
+					have,
+					want,
+				)
+			}
+		})
+	}
+}
diff --git a/system_tests/espresso/execution_engine/doc.go b/system_tests/espresso/execution_engine/doc.go
new file mode 100644
index 00000000000..970ad5f845b
--- /dev/null
+++ b/system_tests/espresso/execution_engine/doc.go
@@ -0,0 +1,10 @@
+// Package execution_engine provides utility mock implementations of the
+// execution engine specifically for testing purposes.
+//
+// Currently this package contains a mock for use with the TransactionStreamer,
+// as it provides implementation details against the interaction discovered
+// within the TransactionStreamer.
+//
+// Additionally, it provides a blank UnimplementedExecutionEngine implementation
+// that allows other Mocks to be created more easily.
+package execution_engine
diff --git a/system_tests/espresso/execution_engine/message_hasher.go b/system_tests/espresso/execution_engine/message_hasher.go
new file mode 100644
index 00000000000..588ca6670aa
--- /dev/null
+++ b/system_tests/espresso/execution_engine/message_hasher.go
@@ -0,0 +1,67 @@
+package execution_engine
+
+import (
+	"crypto"
+
+	"github.com/ethereum/go-ethereum/common"
+	geth_crypo "github.com/ethereum/go-ethereum/crypto"
+
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+)
+
+// MessageHasher is an interface that defines the common hashing functionality
+// for messages with metadata. It allows for different hashing algorithms to be
+// used interchangeably.
+type MessageHasher interface {
+	HashMessageWithMetadata(msg *arbostypes.MessageWithMetadata) common.Hash
+}
+
+// StdLibCryptoHasher is a struct to wrap the crypto.Hash interface defined
+// by the Go standard library. This allows for the substitution or swapping
+// of the hashing algorithms provided by the Go standard library's crypto
+// package.
+type StdLibCryptoHasher struct {
+	Hash crypto.Hash
+}
+
+// Compile time check to ensure that StdLibCryptoHasher implements the
+// MessageHasher interface.
+var _ MessageHasher = StdLibCryptoHasher{}
+
+// NewStdLibHasher creates a new instance of StdLibCryptoHasher with the
+// specified crypto.Hash algorithm.
+func NewStdLibHasher(hash crypto.Hash) StdLibCryptoHasher {
+	return StdLibCryptoHasher{Hash: hash}
+}
+
+// HashMessageWithMetadata implements MessageHasher
+func (h StdLibCryptoHasher) HashMessageWithMetadata(msg *arbostypes.MessageWithMetadata) common.Hash {
+	hasher := h.Hash.New()
+	hasher.Write([]byte{msg.Message.Header.Kind})
+	hasher.Write(msg.Message.L2msg)
+	var hash common.Hash
+	copy(hash[:], hasher.Sum(nil)[:common.HashLength])
+	return hash
+}
+
+// KeccakHasher is a struct that is a place holder for the Keccak hashing
+// algorithm provided by the go-ethereum library.
+type KeccakHasher struct{}
+
+// Compile time check to ensure that KeccakHasher implements the
+// MessageHasher interface.
+var _ MessageHasher = KeccakHasher{}
+
+// HashMessageWithMetadata implements MessageHasher
+func (h KeccakHasher) HashMessageWithMetadata(msg *arbostypes.MessageWithMetadata) common.Hash {
+	keccak := geth_crypo.NewKeccakState()
+	_, _ = keccak.Write([]byte{msg.Message.Header.Kind})
+	_, _ = keccak.Write(msg.Message.L2msg)
+	var hash common.Hash
+	_, _ = keccak.Read(hash[:])
+	return hash
+}
+
+// DefaultMessageHasher is the default MessageHasher used by the
+// MockExecutionEngine.
+var DefaultMessageHasher MessageHasher = KeccakHasher{}
diff --git a/system_tests/espresso/execution_engine/message_hasher_test.go b/system_tests/espresso/execution_engine/message_hasher_test.go
new file mode 100644
index 00000000000..3c204354af3
--- /dev/null
+++ b/system_tests/espresso/execution_engine/message_hasher_test.go
@@ -0,0 +1,48 @@
+package execution_engine_test
+
+import (
+	"crypto"
+	"fmt"
+
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+	execution_engine "github.com/offchainlabs/nitro/system_tests/espresso/execution_engine"
+)
+
+// ExampleKeccakHasher demonstrates how to use the KeccakHasher
+// to hash a message.
+func ExampleKeccakHasher() {
+	msg := &arbostypes.MessageWithMetadata{
+		Message: &arbostypes.L1IncomingMessage{
+			Header: &arbostypes.L1IncomingMessageHeader{},
+		},
+	}
+
+	var hasher execution_engine.KeccakHasher
+	hash := hasher.HashMessageWithMetadata(msg)
+
+	fmt.Printf("Hash of the message: %s\n", hash)
+	// Output: Hash of the message: 0xbc36789e7a1e281436464229828f817d6612f7b477d66591ff96a9e064bcc98a
+}
+
+// ExampleNewStdLibHasher demonstrates how to use the NewStdLibHasher
+// to create a hasher that uses the standard library's crypto package.
+//
+// It hashes a message using the specified hashing algorithm (e.g., SHA256).
+// This example uses SHA256, but you can replace it with any other supported
+// algorithm.
+//
+// NOTE: The StdLibHasher is not expected to be used in production code, or
+// really for testing, but is provided here for convenience and completeness.
+func ExampleNewStdLibHasher() {
+	msg := &arbostypes.MessageWithMetadata{
+		Message: &arbostypes.L1IncomingMessage{
+			Header: &arbostypes.L1IncomingMessageHeader{},
+		},
+	}
+
+	hasher := execution_engine.NewStdLibHasher(crypto.SHA256)
+	hash := hasher.HashMessageWithMetadata(msg)
+
+	fmt.Printf("Hash of the message: %s\n", hash)
+	// Output: Hash of the message: 0x6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d
+}
diff --git a/system_tests/espresso/execution_engine/mock_execution_engine_transaction_streamer.go b/system_tests/espresso/execution_engine/mock_execution_engine_transaction_streamer.go
new file mode 100644
index 00000000000..6a3efad0fd1
--- /dev/null
+++ b/system_tests/espresso/execution_engine/mock_execution_engine_transaction_streamer.go
@@ -0,0 +1,129 @@
+package execution_engine
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+	"github.com/offchainlabs/nitro/arbutil"
+	"github.com/offchainlabs/nitro/execution"
+	"github.com/offchainlabs/nitro/util/containers"
+)
+
+// MockExecutionEngineForTransactionStreamer is a mock implementation of the
+// execution.ExecutionSequencer interface.
+//
+// It implements a minimal set of the methods required.
+// It's current implementation is focused on targeting the methods required
+// for testing the TransactionStreamer and EspressoChain functionality.
+//
+// NOTE: This mock *should* be safe to use between threads.
+// NOTE: The Results map is *MUST* be initialized before any methods are called,
+// it is recommended to use the NewMockExecutionEngineForTransactionStreamer
+// function to ensure that the Results map is initialized.
+type MockExecutionEngineForTransactionStreamer struct {
+	execution.ExecutionClient
+	Lock    sync.RWMutex
+	Latest  arbutil.MessageIndex
+	Results map[arbutil.MessageIndex]*execution.MessageResult
+	Hasher  MessageHasher
+}
+
+// Compile time check to ensure that MockExecutionEngine implements the
+// execution.ExecutionSequencer interface.
+var _ execution.ExecutionClient = &MockExecutionEngineForTransactionStreamer{}
+
+// MockExecutionEngineForTransactionStreamerConfig holds the configuration
+// options for the MockExecutionEngineForTransactionStreamer.
+type MockExecutionEngineForTransactionStreamerConfig struct {
+	Results map[arbutil.MessageIndex]*execution.MessageResult
+	Hasher  MessageHasher
+}
+
+// MockExecutionEngineForTransactionStreamerConfigOption is a function that
+// modifies the MockExecutionEngineForTransactionStreamerConfig. This allows
+// for flexible configuration of the mock execution engine.
+type MockExecutionEngineForTransactionStreamerConfigOption func(cfg *MockExecutionEngineForTransactionStreamerConfig)
+
+// WithHasher allows the caller to override the default hasher used by the
+// MockExecutionEngineForTransactionStreamer.
+func WithHasher(hasher MessageHasher) MockExecutionEngineForTransactionStreamerConfigOption {
+	return func(cfg *MockExecutionEngineForTransactionStreamerConfig) {
+		cfg.Hasher = hasher
+	}
+}
+
+// NewMockExecutionEngineForTransactionStreamer returns an implementation of
+// execution.ExecutionSequencer that can ber used for testing the
+// TransactionStreamer.
+func NewMockExecutionEngineForTransactionStreamer(options ...MockExecutionEngineForTransactionStreamerConfigOption) execution.ExecutionClient {
+	config := MockExecutionEngineForTransactionStreamerConfig{
+		Results: make(map[arbutil.MessageIndex]*execution.MessageResult),
+		Hasher:  DefaultMessageHasher,
+	}
+
+	for _, option := range options {
+		option(&config)
+	}
+
+	return &MockExecutionEngineForTransactionStreamer{
+		Results: config.Results,
+		Hasher:  config.Hasher,
+	}
+}
+
+// DigestMessage implements execution.ExecutionSequencer.
+func (m *MockExecutionEngineForTransactionStreamer) DigestMessage(msgIdx arbutil.MessageIndex, msg *arbostypes.MessageWithMetadata, msgForPrefetch *arbostypes.MessageWithMetadata) containers.PromiseInterface[*execution.MessageResult] {
+	m.Lock.Lock()
+	defer m.Lock.Unlock()
+	hash := m.Hasher.HashMessageWithMetadata(msg)
+	var blockHash common.Hash
+	copy(blockHash[:], hash[:])
+	result := execution.MessageResult{
+		BlockHash: blockHash,
+	}
+
+	m.Results[msgIdx] = &result
+	if m.Latest < msgIdx {
+		m.Latest = msgIdx
+	}
+
+	return containers.NewReadyPromise(&result, nil)
+}
+
+// HeadMessageIndex implements execution.ExecutionSequencer.
+func (m *MockExecutionEngineForTransactionStreamer) HeadMessageIndex() containers.PromiseInterface[arbutil.MessageIndex] {
+	m.Lock.RLock()
+	defer m.Lock.RUnlock()
+	return containers.NewReadyPromise(m.Latest, nil)
+}
+
+// MarkFeedStart implements execution.ExecutionSequencer.
+func (m *MockExecutionEngineForTransactionStreamer) MarkFeedStart(to arbutil.MessageIndex) containers.PromiseInterface[struct{}] {
+	return containers.NewReadyPromise(struct{}{}, nil)
+}
+
+// ErrorExecutionClientUnimplementedMethod is an error type that indicates that
+// no message result was found for the given message index.
+type ErrorNoMessageResultForIndex struct {
+	MsgIdx arbutil.MessageIndex
+}
+
+// Error implements error
+func (e ErrorNoMessageResultForIndex) Error() string {
+	return fmt.Sprintf("no message result found for index %d", e.MsgIdx)
+}
+
+// ResultAtMessageIndex implements execution.ExecutionSequencer.
+func (m *MockExecutionEngineForTransactionStreamer) ResultAtMessageIndex(msgIdx arbutil.MessageIndex) containers.PromiseInterface[*execution.MessageResult] {
+	m.Lock.RLock()
+	defer m.Lock.RUnlock()
+	result, resultOk := m.Results[msgIdx]
+	if !resultOk {
+		return containers.NewReadyPromise[*execution.MessageResult](nil, ErrorNoMessageResultForIndex{msgIdx})
+	}
+
+	return containers.NewReadyPromise(result, nil)
+}
diff --git a/system_tests/espresso/execution_engine/mock_execution_engine_transaction_streamer_test.go b/system_tests/espresso/execution_engine/mock_execution_engine_transaction_streamer_test.go
new file mode 100644
index 00000000000..19938dbaa35
--- /dev/null
+++ b/system_tests/espresso/execution_engine/mock_execution_engine_transaction_streamer_test.go
@@ -0,0 +1,149 @@
+package execution_engine_test
+
+import (
+	"context"
+	"crypto"
+	"fmt"
+
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+	execution_engine "github.com/offchainlabs/nitro/system_tests/espresso/execution_engine"
+)
+
+// ExampleNewMockExecutionEngineForTransactionStreamer demonstrates how to
+// build and utilize the Mock Execution Engine for Transaction Streamer.
+//
+// This example illustrates the features, and anticipated behavior of the
+// Mock Execution Engine for Transaction Streamer.
+func ExampleNewMockExecutionEngineForTransactionStreamer() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	executionEngine := execution_engine.NewMockExecutionEngineForTransactionStreamer()
+
+	{
+		fmt.Print("\n")
+
+		// The Engine starts at index 0 by default.
+		promise := executionEngine.HeadMessageIndex()
+
+		result, err := promise.Await(ctx)
+		if err != nil {
+			panic(fmt.Errorf("expected to get head message index, but got error: %w", err))
+		}
+
+		fmt.Printf("head message index: %d\n", result)
+	}
+
+	{
+		fmt.Print("\n")
+
+		// If you try to ask for a message that hasn't been digested yet, it
+		// will return an error, indicating the failure.
+		promise := executionEngine.ResultAtMessageIndex(1)
+
+		_, err := promise.Await(ctx)
+		if err == nil {
+			panic(fmt.Errorf("expected to not find message index 1, but got no error"))
+		}
+
+		fmt.Printf("received error asking for message index 1: %s\n", err)
+	}
+
+	{
+		fmt.Print("\n")
+
+		// The Engine will advance the message index automatically when
+		// DigestMessage is invoked.
+		promise := executionEngine.DigestMessage(
+			1,
+			&arbostypes.MessageWithMetadata{
+				Message: &arbostypes.L1IncomingMessage{
+					Header: &arbostypes.L1IncomingMessageHeader{},
+				},
+			},
+			nil,
+		)
+
+		result, err := promise.Await(ctx)
+		if err != nil {
+			panic(fmt.Errorf("expected to digest message, but got error: %w", err))
+		}
+
+		fmt.Printf("block hash: %s\nsend root: %s\n", result.BlockHash.Hex(), result.SendRoot.Hex())
+	}
+
+	{
+		fmt.Print("\n")
+
+		// The Engine will reflect the new head message index after digesting a
+		// message.
+		promise := executionEngine.HeadMessageIndex()
+
+		result, err := promise.Await(ctx)
+		if err != nil {
+			panic(err)
+		}
+
+		fmt.Printf("head message index: %d\n", result)
+	}
+
+	{
+		fmt.Print("\n")
+
+		// The Digested message should be retrievable now by its index.
+		promise := executionEngine.ResultAtMessageIndex(1)
+
+		result, err := promise.Await(ctx)
+		if err != nil {
+			panic(fmt.Errorf("expected to find message index 1, but got error: %w", err))
+		}
+
+		fmt.Printf("block hash: %s\nsend root: %s\n", result.BlockHash.Hex(), result.SendRoot.Hex())
+	}
+
+	// Output:
+	// head message index: 0
+	//
+	// received error asking for message index 1: no message result found for index 1
+	//
+	// block hash: 0xbc36789e7a1e281436464229828f817d6612f7b477d66591ff96a9e064bcc98a
+	// send root: 0x0000000000000000000000000000000000000000000000000000000000000000
+	//
+	// head message index: 1
+	//
+	// block hash: 0xbc36789e7a1e281436464229828f817d6612f7b477d66591ff96a9e064bcc98a
+	// send root: 0x0000000000000000000000000000000000000000000000000000000000000000
+}
+
+// ExampleWithHasher demonstrates how to use a custom hasher with the
+// NewMockExecutionEngineForTransactionStreamer function.
+func ExampleWithHasher() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// Create a mock execution engine with a custom hasher.
+	executionEngine := execution_engine.NewMockExecutionEngineForTransactionStreamer(
+		execution_engine.WithHasher(execution_engine.NewStdLibHasher(crypto.SHA256)),
+	)
+
+	// Digest a message using the custom hasher.
+	promise := executionEngine.DigestMessage(
+		1,
+		&arbostypes.MessageWithMetadata{
+			Message: &arbostypes.L1IncomingMessage{
+				Header: &arbostypes.L1IncomingMessageHeader{},
+			},
+		},
+		nil,
+	)
+
+	result, err := promise.Await(ctx)
+	if err != nil {
+		panic(fmt.Errorf("expected to digest message, but got error: %w", err))
+	}
+
+	fmt.Printf("block hash: %s\nsend root: %s\n", result.BlockHash.Hex(), result.SendRoot.Hex())
+
+	// Output:
+	// block hash: 0x6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d
+	// send root: 0x0000000000000000000000000000000000000000000000000000000000000000
+}
diff --git a/system_tests/espresso/execution_engine/unimplemented_execution_engine.go b/system_tests/espresso/execution_engine/unimplemented_execution_engine.go
new file mode 100644
index 00000000000..24bf2e93c88
--- /dev/null
+++ b/system_tests/espresso/execution_engine/unimplemented_execution_engine.go
@@ -0,0 +1,116 @@
+package execution_engine
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+	"github.com/offchainlabs/nitro/arbutil"
+	"github.com/offchainlabs/nitro/execution"
+	"github.com/offchainlabs/nitro/util/containers"
+)
+
+// ErrorExecutionClientUnimplementedMethod is an error type that is returned
+// when an unimplemented method of the execution.ExecutionClient interface
+// is invoked.
+type ErrorExecutionClientUnimplementedMethod struct {
+	Method string
+}
+
+// Error implements error
+func (e ErrorExecutionClientUnimplementedMethod) Error() string {
+	return fmt.Sprintf("unimplemented method for execution client: %s", e.Method)
+}
+
+// UnimplementedExecutionClient is an implementation of
+// execution.ExecutionClient with all methods resulting in a panic
+// on invocation.
+//
+// This is useful, as it allows future implementors to create simpler
+// mocks by falling back on this implementation, rather than
+// implementing all methods of the interface.
+type UnimplementedExecutionClient struct{}
+
+// MaintenanceStatus implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) MaintenanceStatus() containers.PromiseInterface[*execution.MaintenanceStatus] {
+	panic("unimplemented")
+}
+
+// SetConsensusSyncData implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) SetConsensusSyncData(syncData *execution.ConsensusSyncData) containers.PromiseInterface[struct{}] {
+	panic("unimplemented")
+}
+
+// ShouldTriggerMaintenance implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) ShouldTriggerMaintenance() containers.PromiseInterface[bool] {
+	panic("unimplemented")
+}
+
+// TriggerMaintenance implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) TriggerMaintenance() containers.PromiseInterface[struct{}] {
+	panic("unimplemented")
+}
+
+// Compile time check to ensure that UnimplementedExecutionClient implements
+// the execution.ExecutionClient interface.
+var _ execution.ExecutionClient = UnimplementedExecutionClient{}
+
+func (u UnimplementedExecutionClient) ArbOSVersionForMessageIndex(msgIdx arbutil.MessageIndex) containers.PromiseInterface[uint64] {
+	panic(ErrorExecutionClientUnimplementedMethod{"ArbOSVersionForMessageIndex"})
+}
+
+// BlockNumberToMessageIndex implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) BlockNumberToMessageIndex(blockNum uint64) containers.PromiseInterface[arbutil.MessageIndex] {
+	panic(ErrorExecutionClientUnimplementedMethod{"BlockNumberToMessageIndex"})
+}
+
+// HeadMessageIndex implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) HeadMessageIndex() containers.PromiseInterface[arbutil.MessageIndex] {
+	panic(ErrorExecutionClientUnimplementedMethod{"HeadMessageIndex"})
+}
+
+// Maintenance implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) Maintenance() containers.PromiseInterface[struct{}] {
+	panic(ErrorExecutionClientUnimplementedMethod{"Maintenance"})
+}
+
+// MarkFeedStart implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) MarkFeedStart(to arbutil.MessageIndex) containers.PromiseInterface[struct{}] {
+	panic(ErrorExecutionClientUnimplementedMethod{"MarkFeedStart"})
+}
+
+// MessageIndexToBlockNumber implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) MessageIndexToBlockNumber(messageNum arbutil.MessageIndex) containers.PromiseInterface[uint64] {
+	panic(ErrorExecutionClientUnimplementedMethod{"MessageIndexToBlockNumber"})
+}
+
+// Reorg implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) Reorg(msgIdxOfFirstMsgToAdd arbutil.MessageIndex, newMessages []arbostypes.MessageWithMetadataAndBlockInfo, oldMessages []*arbostypes.MessageWithMetadata) containers.PromiseInterface[[]*execution.MessageResult] {
+	panic(ErrorExecutionClientUnimplementedMethod{"Reorg"})
+}
+
+// ResultAtMessageIndex implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) ResultAtMessageIndex(msgIdx arbutil.MessageIndex) containers.PromiseInterface[*execution.MessageResult] {
+	panic(ErrorExecutionClientUnimplementedMethod{"ResultAtMessageIndex"})
+}
+
+// SetFinalityData implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) SetFinalityData(safeFinalityData *arbutil.FinalityData, finalizedFinalityData *arbutil.FinalityData, validatedFinalityData *arbutil.FinalityData) containers.PromiseInterface[struct{}] {
+	panic(ErrorExecutionClientUnimplementedMethod{"SetFinalityData"})
+}
+
+// Start implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) Start(ctx context.Context) error {
+	panic(ErrorExecutionClientUnimplementedMethod{"Start"})
+}
+
+// StopAndWait implements execution.ExecutionClient.
+func (u UnimplementedExecutionClient) StopAndWait() {
+	panic(ErrorExecutionClientUnimplementedMethod{"StopAndWait"})
+}
+
+// DigestMessage implements execution.ExecutionClient
+// This
+func (UnimplementedExecutionClient) DigestMessage(msgIdx arbutil.MessageIndex, msg *arbostypes.MessageWithMetadata, msgForPrefetch *arbostypes.MessageWithMetadata) containers.PromiseInterface[*execution.MessageResult] {
+	panic(ErrorExecutionClientUnimplementedMethod{"DigestMessage"})
+}
diff --git a/system_tests/espresso/execution_engine/unimplemented_execution_engine_test.go b/system_tests/espresso/execution_engine/unimplemented_execution_engine_test.go
new file mode 100644
index 00000000000..c8cd64ae136
--- /dev/null
+++ b/system_tests/espresso/execution_engine/unimplemented_execution_engine_test.go
@@ -0,0 +1,121 @@
+package execution_engine_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	execution_engine "github.com/offchainlabs/nitro/system_tests/espresso/execution_engine"
+)
+
+// expectPanicWithErrorExecutionClientUnimplementedMethod is a helper function
+// that expects a panic to occur when the provided function is called.
+//
+// It checks that the panic is of type execution_engine.ErrorExecutionClientUnimplementedMethod
+// and that the method name matches the expected method name.
+func expectPanicWithErrorExecutionClientUnimplementedMethod(t *testing.T, fn func(), methodName string) {
+	defer func() {
+		err := recover()
+		if have, want := err, (any)(nil); have == want {
+			t.Errorf("expected recover to recover from panic:\nhave:\n\t\"%v\"\ndo not want:\n\t\"%v\"", have, want)
+			return
+		}
+
+		cast, castOk := err.(execution_engine.ErrorExecutionClientUnimplementedMethod)
+
+		if have, want := castOk, true; have != want {
+			t.Errorf("expected cast to be execution_engine.ErrorExecutionClientUnimplementedMethod:\nhave:\n\t\"%v\"\nwant:\n\t\"%v\"", have, want)
+			return
+		}
+
+		if have, want := cast.Method, methodName; have != want {
+			t.Errorf("expected method name to match:\nhave:\n\t\"%v\"\nwant:\n\t\"%v\"", have, want)
+			return
+		}
+	}()
+
+	fn()
+}
+
+// TestUnimplementedExecutionClient tests the UnimplementedExecutionClient
+// to ensure that it panics when any of its methods are called.
+func TestUnimplementedExecutionClient(t *testing.T) {
+	var client execution_engine.UnimplementedExecutionClient
+
+	t.Run("BlockNumberToMessageIndex", func(t *testing.T) {
+		expectPanicWithErrorExecutionClientUnimplementedMethod(t, func() {
+			client.BlockNumberToMessageIndex(0)
+		}, "BlockNumberToMessageIndex")
+	})
+
+	t.Run("HeadMessageIndex", func(t *testing.T) {
+		expectPanicWithErrorExecutionClientUnimplementedMethod(t, func() {
+			client.HeadMessageIndex()
+		}, "HeadMessageIndex")
+	})
+
+	t.Run("Maintenance", func(t *testing.T) {
+		expectPanicWithErrorExecutionClientUnimplementedMethod(t, func() {
+			client.Maintenance()
+		}, "Maintenance")
+	})
+
+	t.Run("MarkFeedStart", func(t *testing.T) {
+		expectPanicWithErrorExecutionClientUnimplementedMethod(t, func() {
+			client.MarkFeedStart(0)
+		}, "MarkFeedStart")
+	})
+
+	t.Run("MessageIndexToBlockNumber", func(t *testing.T) {
+		expectPanicWithErrorExecutionClientUnimplementedMethod(t, func() {
+			client.MessageIndexToBlockNumber(0)
+		}, "MessageIndexToBlockNumber")
+	})
+
+	t.Run("Reorg", func(t *testing.T) {
+		expectPanicWithErrorExecutionClientUnimplementedMethod(t, func() {
+			client.Reorg(0, nil, nil)
+		}, "Reorg")
+	})
+
+	t.Run("ResultAtMessageIndex", func(t *testing.T) {
+		expectPanicWithErrorExecutionClientUnimplementedMethod(t, func() {
+			_ = client.ResultAtMessageIndex(0)
+		}, "ResultAtMessageIndex")
+	})
+
+	t.Run("SetFinalityData", func(t *testing.T) {
+		expectPanicWithErrorExecutionClientUnimplementedMethod(t, func() {
+			_ = client.SetFinalityData(nil, nil, nil)
+		}, "SetFinalityData")
+	})
+
+	t.Run("Start", func(t *testing.T) {
+		expectPanicWithErrorExecutionClientUnimplementedMethod(t, func() {
+			_ = client.Start(context.Background())
+		}, "Start")
+	})
+
+	t.Run("StopAndWait", func(t *testing.T) {
+		expectPanicWithErrorExecutionClientUnimplementedMethod(t, func() {
+			client.StopAndWait()
+		}, "StopAndWait")
+	})
+
+	t.Run("DigestMessage", func(t *testing.T) {
+		expectPanicWithErrorExecutionClientUnimplementedMethod(t, func() {
+			_ = client.DigestMessage(0, nil, nil)
+		}, "DigestMessage")
+	})
+}
+
+// ExampleErrorExecutionClientUnimplementedMethod demonstrates how to use the
+// ErrorExecutionClientUnimplementedMethod error type.
+func ExampleErrorExecutionClientUnimplementedMethod() {
+	err := execution_engine.ErrorExecutionClientUnimplementedMethod{
+		Method: "Hello",
+	}
+
+	fmt.Printf("Error: %s\n", err.Error())
+	// Output: Error: unimplemented method for execution client: Hello
+}
diff --git a/system_tests/espresso/generate/doc.go b/system_tests/espresso/generate/doc.go
new file mode 100644
index 00000000000..0a489f039c1
--- /dev/null
+++ b/system_tests/espresso/generate/doc.go
@@ -0,0 +1,3 @@
+// Package generate provides utilities for generating mock and fake data to
+// be utilized for testing purposes.
+package generate
diff --git a/system_tests/espresso/generate/messages.go b/system_tests/espresso/generate/messages.go
new file mode 100644
index 00000000000..2df42cc5bf7
--- /dev/null
+++ b/system_tests/espresso/generate/messages.go
@@ -0,0 +1,238 @@
+package generate
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"time"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/rlp"
+
+	"github.com/offchainlabs/nitro/arbos/arbostypes"
+	"github.com/offchainlabs/nitro/arbutil"
+	"github.com/offchainlabs/nitro/execution"
+	execution_engine "github.com/offchainlabs/nitro/system_tests/espresso/execution_engine"
+)
+
+// MessageFromSequencerWriter is an interface that defines a method to write
+// messages from the sequencer to a writer.
+type MessageFromSequencerWriter interface {
+	WriteMessageFromSequencer(
+		msgIdx arbutil.MessageIndex,
+		msgWithMeta arbostypes.MessageWithMetadata,
+		msgResult execution.MessageResult,
+		blockMetadata common.BlockMetadata,
+	) error
+}
+
+// Message is a struct that holds the generated message data that
+// is needed for the TransactionStreamer to process messages.
+type Message struct {
+	pos           arbutil.MessageIndex
+	msgWithMeta   arbostypes.MessageWithMetadata
+	msgResult     execution.MessageResult
+	blockMetadata common.BlockMetadata
+}
+
+// GenerateMessage is a function that generates a message with a given index
+// and a specified size, utilizing the specified hasher to generate the hash.
+func GenerateMessage(
+	i arbutil.MessageIndex,
+	hasher execution_engine.MessageHasher,
+	size uint64,
+) Message {
+	msgData := make([]byte, size)
+	_, _ = rand.Read(msgData) // Fill msgData with random bytes
+	// We write the index to the message data
+	// This can help to identify when debugging issues
+	binary.BigEndian.PutUint64(msgData, uint64(i))
+	msg := arbostypes.MessageWithMetadataAndBlockInfo{
+		MessageWithMeta: arbostypes.MessageWithMetadata{
+			Message: &arbostypes.L1IncomingMessage{
+				Header: &arbostypes.L1IncomingMessageHeader{
+					Kind: arbostypes.L1MessageType_L2Message,
+				},
+				L2msg: msgData,
+			},
+			DelayedMessagesRead: 0,
+		},
+		BlockHash:     nil,
+		BlockMetadata: nil,
+	}
+	_ = msg.BlockHash     // avoid unused warning
+	_ = msg.BlockMetadata // avoid unused warning
+	hash := hasher.HashMessageWithMetadata(&msg.MessageWithMeta)
+	msgResult := &execution.MessageResult{
+		BlockHash: hash,
+	}
+	return Message{
+		pos:           i,
+		msgWithMeta:   msg.MessageWithMeta,
+		msgResult:     *msgResult,
+		blockMetadata: nil,
+	}
+}
+
+// GenerationBehavior is a function that controls the rate and attributes of
+// messages being generated.
+type GenerationBehavior func(ctx context.Context, hasher execution_engine.MessageHasher, ch chan<- Message, i arbutil.MessageIndex) arbutil.MessageIndex
+
+// PreloadMessages is a GenerationBehavior that generates N messages without
+// delay. The messages are generated with the specified size for convenience.
+func PreloadMessages(n arbutil.MessageIndex, size uint64) GenerationBehavior {
+	return func(ctx context.Context, hasher execution_engine.MessageHasher, ch chan<- Message, i arbutil.MessageIndex) arbutil.MessageIndex {
+		j := arbutil.MessageIndex(0)
+		for ; j < n; j++ {
+			select {
+			default:
+			case <-ctx.Done():
+				return i + j
+			}
+
+			ch <- GenerateMessage(i+j, hasher, size)
+		}
+
+		return j + i
+	}
+}
+
+// ProduceMessagesOfSizeAtInterval is a GenerationBehavior that generates N
+// messages of a specific size at a specified interval. This is useful for
+// simulating a steady stream of messages being produced over time at
+// a consistent interval and time.
+func ProduceMessagesOfSizeAtInterval(n arbutil.MessageIndex, size uint64, interval time.Duration) GenerationBehavior {
+	return func(ctx context.Context, hasher execution_engine.MessageHasher, ch chan<- Message, i arbutil.MessageIndex) arbutil.MessageIndex {
+		ticker := time.NewTicker(interval)
+		defer ticker.Stop()
+		j := arbutil.MessageIndex(0)
+		for ; j < n; j++ {
+			select {
+			case <-ctx.Done():
+				return i + j
+
+			case <-ticker.C:
+				ch <- GenerateMessage(i+j, hasher, size)
+			}
+		}
+
+		return i + j
+	}
+}
+
+// DefaultMoltenMessageSize is the default size of the messages generated for
+// Molten environments.
+//
+// This sized is based on the average size of the messages observed in Molten
+const DefaultMoltenMessageSize = 3 * 1024 // 3 KiB
+
+// PreloadMoltenMessages is a GenerationBehavior that generates N Molten
+// messages without delay.  The messages are generated with the specific
+// observed Molten message size.
+func PreloadMoltenMessages(n arbutil.MessageIndex) GenerationBehavior {
+	return PreloadMessages(n, DefaultMoltenMessageSize)
+}
+
+// DefaultMoltenTimeBetweenMessages is the default time interval between
+// messages generated for Molten environments.
+//
+// This duration is based on the average time between messages observed in
+// Molten environments.
+const DefaultMoltenTimeBetweenMessages = 250 * time.Millisecond
+
+// GenerateStandardMoltenMessages is a GenerationBehavior that generates N
+// messages with the specific observed Molten standards.
+func GenerateStandardMoltenMessages(n arbutil.MessageIndex) GenerationBehavior {
+	return ProduceMessagesOfSizeAtInterval(n, DefaultMoltenMessageSize, 250*time.Millisecond)
+}
+
+// ProduceMessages is a function that is meant to be run in a goroutine.
+// It continuously generates messages based on the provided behaviors.
+// This function will automatically close the channel when all behaviors have
+// been executed, ensuring that the channel is properly cleaned up.
+func ProduceMessages(ctx context.Context, hasher execution_engine.MessageHasher, ch chan<- Message, behaviors ...GenerationBehavior) {
+	defer close(ch)
+	var i arbutil.MessageIndex
+	for _, behavior := range behaviors {
+		select {
+		default:
+		case <-ctx.Done():
+			return
+		}
+
+		i = behavior(ctx, hasher, ch, i)
+	}
+}
+
+// sendMessageToWriter is a helper function that sends a message to the
+// MessageFromSequencerWriter. It handles the actual writing of the message
+// to the writer, which is typically the TransactionStreamer.
+//
+// This function simply exists to make the transition between a Message
+// and the MessageFromSequencerWriter easier.
+func sendMessageToWriter(w MessageFromSequencerWriter, m Message) error {
+	return w.WriteMessageFromSequencer(
+		m.pos,
+		m.msgWithMeta,
+		m.msgResult,
+		m.blockMetadata,
+	)
+}
+
+// SendMessageToWriter is a function that is meant to be run in a goroutine.
+// It continuously reads messages from the provided channel and sends them to
+// the provided MessageFromSequencerWriter. It will return an error if it
+// encounters an error while sending a message or if the context is done.
+//
+// NOTE: This function runs as quickly as possible, so any delay in processing
+// depends on the messages coming in from the channel itself.
+func SendMessageToWriter(ctx context.Context, w MessageFromSequencerWriter, ch <-chan Message) error {
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+
+		case m, ok := <-ch:
+			if !ok {
+				return nil // Channel closed, exit gracefully
+			}
+
+			if err := sendMessageToWriter(w, m); err != nil {
+				return err
+			}
+		}
+	}
+}
+
+// ConvertEspressoTransactionsInBlockToMessages is a helper function that converts
+// Espresso transactions in a block to messages with metadata.
+func ConvertEspressoTransactionsInBlockToMessages(
+	blockWithTx espresso_client.TransactionsInBlock,
+) ([]arbostypes.MessageWithMetadata, error) {
+	messagesWithMetadata := make([]arbostypes.MessageWithMetadata, 0, len(blockWithTx.Transactions))
+
+	for _, tx := range blockWithTx.Transactions {
+		// We can parse the transactions to get the messages
+		// This is a mock function that simulates the parsing of the transaction
+		// In a real scenario, this would be replaced with the actual parsing logic
+		_, _, _, messages, err := arbutil.ParseHotShotPayload(tx)
+		if err != nil {
+			return nil, fmt.Errorf("encountered error while parsing transaction: %w", err)
+		}
+
+		for _, message := range messages {
+			var messageWithMetadata arbostypes.MessageWithMetadata
+			if have, want := rlp.DecodeBytes(message, &messageWithMetadata), error(nil); !errors.Is(have, want) {
+				return nil, fmt.Errorf("encountered error while decoding message: %w", have)
+			}
+
+			messagesWithMetadata = append(messagesWithMetadata, messageWithMetadata)
+		}
+	}
+
+	return messagesWithMetadata, nil
+}
diff --git a/system_tests/espresso/key_manager/mock_espresso_key_manager.go b/system_tests/espresso/key_manager/mock_espresso_key_manager.go
new file mode 100644
index 00000000000..59242f1baab
--- /dev/null
+++ b/system_tests/espresso/key_manager/mock_espresso_key_manager.go
@@ -0,0 +1,115 @@
+package key_manager
+
+import (
+	"crypto/ecdsa"
+	crypto_rand "crypto/rand"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/crypto"
+
+	key_manager "github.com/offchainlabs/nitro/espresso/key-manager"
+	"github.com/offchainlabs/nitro/espressotee"
+)
+
+// MockEspressoKeyManager is a mock implementation of the
+// key_manager.EspressoKeyManagerInterface.
+//
+// It is used for testing purposes and provides a simple implementation
+// of the Espresso key management functionality without requiring a real
+// Espresso environment.
+type MockEspressoKeyManager struct {
+	Key *ecdsa.PrivateKey
+}
+
+// Compile time check to ensure that MockEspressoKeyManager implements the
+// key_manager.EspressoKeyManagerInterface.
+var _ key_manager.EspressoKeyManagerInterface = &MockEspressoKeyManager{}
+
+// MockEspressoKeyManagerConfig holds the configuration options for the
+// MockEspressoKeyManager. It governs the customization of the
+// MockEspressoKeyManager at the time of its creation using the
+// NewMockEspressoKeyManager function.
+type MockEspressoKeyManagerConfig struct {
+	PrivateKey *ecdsa.PrivateKey
+}
+
+// MockEspressoKeyManagerOption is a function that configures the
+// MockEspressoKeyManagerConfig.
+type MockEspressoKeyManagerOption func(*MockEspressoKeyManagerConfig)
+
+// WithPrivateKey is a MockEspressoKeyManagerOption that allows setting a
+// custom private key for the MockEspressoKeyManager.
+func WithPrivateKey(privKey *ecdsa.PrivateKey) MockEspressoKeyManagerOption {
+	return func(config *MockEspressoKeyManagerConfig) {
+		config.PrivateKey = privKey
+	}
+}
+
+// mustGenerateNewPrivateKey generates a new ECDSA private key using the
+// crypto/rand package.
+//
+// NOTE: This function panics if the key generation fails.
+func mustGenerateNewPrivateKey() *ecdsa.PrivateKey {
+	privKey, err := ecdsa.GenerateKey(crypto.S256(), crypto_rand.Reader)
+	if err != nil {
+		panic(fmt.Sprintf("failed to generate mock private key: %v", err))
+	}
+	return privKey
+}
+
+// NewMockEspressoKeyManager creates a new instance of MockEspressoKeyManager
+// with a randomly generated private key.
+func NewMockEspressoKeyManager(options ...MockEspressoKeyManagerOption) *MockEspressoKeyManager {
+	// Setup config with default options / values
+	config := MockEspressoKeyManagerConfig{
+		PrivateKey: mustGenerateNewPrivateKey(),
+	}
+
+	for _, option := range options {
+		option(&config)
+	}
+
+	return &MockEspressoKeyManager{
+		Key: config.PrivateKey,
+	}
+}
+
+// GetCurrentKey implements key_manager.EspressoKeyManagerInterface.
+func (m *MockEspressoKeyManager) GetCurrentKey() *ecdsa.PublicKey {
+	return &m.Key.PublicKey
+}
+
+// HasRegistered implements key_manager.EspressoKeyManagerInterface.
+func (m *MockEspressoKeyManager) HasRegistered() bool {
+	return false
+}
+
+func (m *MockEspressoKeyManager) GetKeyManagerState() key_manager.KeyManagerState {
+	return key_manager.Registered
+}
+
+// Register implements key_manager.EspressoKeyManagerInterface.
+func (m *MockEspressoKeyManager) Register(getAttestationFunc func([]byte) ([]byte, error)) error {
+	return nil
+}
+
+// SignMessage implements key_manager.EspressoKeyManagerInterface.
+func (m *MockEspressoKeyManager) SignMessage(message []byte) ([]byte, error) {
+	hash := crypto.Keccak256Hash(message)
+	return crypto.Sign(hash.Bytes(), m.Key)
+}
+
+// SignHotShotPayload implements key_manager.EspressoKeyManagerInterface.
+func (m *MockEspressoKeyManager) SignPayload(message []byte) ([]byte, error) {
+	hash := crypto.Keccak256Hash(message)
+	return crypto.Sign(hash.Bytes(), m.Key)
+}
+
+// TeeType implements key_manager.EspressoKeyManagerInterface.
+func (m *MockEspressoKeyManager) TeeType() espressotee.TEE {
+	return espressotee.NITRO
+}
+
+func (m *MockEspressoKeyManager) CheckRegistration() (bool, error) {
+	return true, nil
+}
diff --git a/system_tests/espresso/key_manager/mock_espresso_key_manager_test.go b/system_tests/espresso/key_manager/mock_espresso_key_manager_test.go
new file mode 100644
index 00000000000..3af3998d7c2
--- /dev/null
+++ b/system_tests/espresso/key_manager/mock_espresso_key_manager_test.go
@@ -0,0 +1,82 @@
+package key_manager_test
+
+import (
+	"crypto/ecdsa"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/crypto"
+
+	"github.com/offchainlabs/nitro/system_tests/espresso/key_manager"
+)
+
+// fakeRandReader is a simple implementation of io.Reader that returns a
+// deterministic byte slice. This is used for testing purposes to ensure
+// consistent behavior in tests.
+type fakeRandReader struct{}
+
+// Read implements the io.Reader
+//
+// This implementation simply fills the byte slice with an ascending sequence of
+// values from 0 to 255, repeating as necessary. This is not secure and should
+// only be used for testing purposes.
+func (f *fakeRandReader) Read(p []byte) (n int, err error) {
+	// Fill the byte slice with a simple pattern, for deterministic output.
+	for i, l, b := uint64(0), uint64(len(p)), uint8(0); i < l; i, b = i+1, b+1 {
+		p[i] = b
+	}
+
+	return len(p), nil
+}
+
+// ExampleNewMockEspressoKeyManager demonstrates how to create a new
+// MockEspressoKeyManager instance with a private key, and how to use it to
+// sign messages and retrieve the public key.
+func ExampleNewMockEspressoKeyManager() {
+	// NOTE: This example uses a deterministic random reader for the
+	// private key generation for this example to work.  In practice, you
+	// should always use a secure random number generator, such as
+	// crypto/rand.Reader
+	privateKey, err := ecdsa.GenerateKey(crypto.S256(), new(fakeRandReader))
+	if err != nil {
+		panic(fmt.Errorf("failed to generate private key: %w", err))
+	}
+
+	km := key_manager.NewMockEspressoKeyManager(
+		key_manager.WithPrivateKey(privateKey),
+	)
+
+	{
+		// Public Key
+		publicKey := km.GetCurrentKey()
+		address := crypto.PubkeyToAddress(*publicKey)
+
+		fmt.Printf("public key: %x\n", address)
+		fmt.Printf("address from public key: %s\n", address)
+	}
+
+	{
+		// Sign SignHotShotPayload example
+		signature, err := km.SignPayload([]byte("hotshot payload"))
+		if err != nil {
+			panic(err)
+		}
+
+		fmt.Printf("signature for sign hotshot payload: %x\n", signature)
+	}
+
+	{
+		// Sign Batch Example
+		signature, err := km.SignMessage([]byte("test message"))
+		if err != nil {
+			panic(err)
+		}
+
+		fmt.Printf("signature for batch: %x\n", signature)
+	}
+
+	// Output:
+	// public key: ede35562d3555e61120a151b3c8e8e91d83a378a
+	// address from public key: 0xedE35562d3555e61120a151B3c8e8e91d83a378a
+	// signature for sign hotshot payload: 68a9dc2c647ea7a46401da33410937c4eebd26fc3555ec27f49e1dedc1a365ec7db54dc6a420d2c5331beb1f62537ead5b8df3d477191ef6c6555400c995c69301
+	// signature for batch: b709442f40834aeb37134db52e846737101cf403d337e463a8980546507fcb3f07da4926475c90f2349b7812977e3788f43b18f8bcf128e08cb3b685b3298cd001
+}
diff --git a/system_tests/espresso/light_client/doc.go b/system_tests/espresso/light_client/doc.go
new file mode 100644
index 00000000000..307132ee282
--- /dev/null
+++ b/system_tests/espresso/light_client/doc.go
@@ -0,0 +1,7 @@
+// Package light_client provides mocks and other implementations to simulate a
+// simple Espresso Light Client environment for testing purposes.
+//
+// It also provides an UnimplementedLightClient, which can be used to create
+// other mocks that implement the LightClient interface without needing to
+// implement all methods.
+package light_client
diff --git a/system_tests/espresso/light_client/mock_always_live_light_client_reader.go b/system_tests/espresso/light_client/mock_always_live_light_client_reader.go
new file mode 100644
index 00000000000..04d52ba9342
--- /dev/null
+++ b/system_tests/espresso/light_client/mock_always_live_light_client_reader.go
@@ -0,0 +1,26 @@
+package light_client
+
+import (
+	espresso_light_client "github.com/EspressoSystems/espresso-network/sdks/go/light-client"
+)
+
+// MockAlwaysLiveLightClientReader is a mock implementation of the
+// espresso_light_client.LightClientReaderInterface  that always returns
+// true for IsHotShotLive, simulating a scenario where the light client is
+// always live.
+type MockAlwaysLiveLightClientReader struct {
+	UnimplementedLightClientReader
+}
+
+// This is compile time check to ensure that MockAlwaysLiveLightClientReader
+// implements LightClientReaderInterface.
+var _ espresso_light_client.LightClientReaderInterface = &UnimplementedLightClientReader{}
+
+// IsHotShotLive is a mock implementation that always returns true,
+func (m *MockAlwaysLiveLightClientReader) IsHotShotLive(delayThreshold uint64) (bool, error) {
+	return true, nil
+}
+
+func NewMockAlwaysLiveLightClientReader() *MockAlwaysLiveLightClientReader {
+	return new(MockAlwaysLiveLightClientReader)
+}
diff --git a/system_tests/espresso/light_client/mock_always_live_light_client_reader_test.go b/system_tests/espresso/light_client/mock_always_live_light_client_reader_test.go
new file mode 100644
index 00000000000..4ce53b11be8
--- /dev/null
+++ b/system_tests/espresso/light_client/mock_always_live_light_client_reader_test.go
@@ -0,0 +1,25 @@
+package light_client_test
+
+import (
+	"testing"
+
+	light_client "github.com/offchainlabs/nitro/system_tests/espresso/light_client"
+)
+
+// TestMockAlwaysLiveLightClientReader tests the MockAlwaysLiveLightClientReader
+// to ensure that it always returns true for IsHotShotLive, simulating a
+// scenario where Hot Shot is always live.
+func TestMockAlwaysLiveLightClientReader(t *testing.T) {
+	// This test ensures that the MockAlwaysLiveLightClientReader always returns true
+	// for IsHotShotLive, simulating a scenario where the light client is always live.
+	client := light_client.NewMockAlwaysLiveLightClientReader()
+
+	isLive, err := client.IsHotShotLive(0)
+	if err != nil {
+		t.Fatalf("isHotShotLive is not expected to ever return an error:have:\n\t%v", err)
+	}
+
+	if have, want := isLive, true; have != want {
+		t.Fatalf("expected IsHotShotLive to return true:\nhave:\n\t%v\nwant:\n\t%v", have, want)
+	}
+}
diff --git a/system_tests/espresso/light_client/unimplemented_light_client_reader.go b/system_tests/espresso/light_client/unimplemented_light_client_reader.go
new file mode 100644
index 00000000000..084553efcfa
--- /dev/null
+++ b/system_tests/espresso/light_client/unimplemented_light_client_reader.go
@@ -0,0 +1,53 @@
+package light_client
+
+import (
+	"fmt"
+
+	espresso_light_client "github.com/EspressoSystems/espresso-network/sdks/go/light-client"
+	"github.com/EspressoSystems/espresso-network/sdks/go/types/common"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+)
+
+// ErrorLightClientUnimplementedMethod is an error type that is returned when a
+// method of the LightClientReaderInterface is called that has not been
+// implemented.
+type ErrorLightClientUnimplementedMethod struct {
+	Method string
+}
+
+// Error implements error
+func (e ErrorLightClientUnimplementedMethod) Error() string {
+	return fmt.Sprintf("unimplemented light-client method: %s", e.Method)
+}
+
+// UnimplementedLightClientReader is a struct that implements the
+// espresso_light_client.LightClientReaderInterface but panics on all method
+// calls. This is useful for testing purposes when you want to ensure that a
+// method is not called or to provide a default implementation that can be
+// overridden in tests.
+type UnimplementedLightClientReader struct{}
+
+// Compile time check to ensure that UnimplementedLightClientReader implements
+// the espresso_light_client.LightClientReaderInterface.
+var _ espresso_light_client.LightClientReaderInterface = &UnimplementedLightClientReader{}
+
+// FetchMerkleRoot implements lightclient.LightClientReaderInterface.
+func (u *UnimplementedLightClientReader) FetchMerkleRoot(hotShotHeight uint64, opts *bind.CallOpts) (common.BlockMerkleSnapshot, error) {
+	panic(ErrorLightClientUnimplementedMethod{Method: "FetchMerkleRoot"})
+}
+
+// IsHotShotLive implements lightclient.LightClientReaderInterface.
+func (u *UnimplementedLightClientReader) IsHotShotLive(delayThreshold uint64) (bool, error) {
+	panic(ErrorLightClientUnimplementedMethod{Method: "IsHotShotLive"})
+}
+
+// IsHotShotLiveAtHeight implements lightclient.LightClientReaderInterface.
+func (u *UnimplementedLightClientReader) IsHotShotLiveAtHeight(height uint64, delayThreshold uint64) (bool, error) {
+	panic(ErrorLightClientUnimplementedMethod{Method: "IsHotShotLiveAtHeight"})
+}
+
+// ValidatedHeight implements lightclient.LightClientReaderInterface.
+func (u *UnimplementedLightClientReader) ValidatedHeight() (validatedHeight uint64, l1Height uint64, err error) {
+	panic(ErrorLightClientUnimplementedMethod{Method: "ValidatedHeight"})
+}
diff --git a/system_tests/espresso/light_client/unimplemented_light_client_reader_test.go b/system_tests/espresso/light_client/unimplemented_light_client_reader_test.go
new file mode 100644
index 00000000000..aba58568e47
--- /dev/null
+++ b/system_tests/espresso/light_client/unimplemented_light_client_reader_test.go
@@ -0,0 +1,78 @@
+package light_client_test
+
+import (
+	"fmt"
+	"testing"
+
+	light_client "github.com/offchainlabs/nitro/system_tests/espresso/light_client"
+)
+
+// expectPanicWithErrorLightClientUnimplementedMethod is a helper function that
+// expects a panic to occur when the provided function is called.
+//
+// It checks that the panic is of type light_client.ErrorLightClientUnimplementedMethod
+// and that the method name matches the expected method name.
+func expectPanicWithErrorLightClientUnimplementedMethod(t *testing.T, fn func(), methodName string) {
+	defer func() {
+		err := recover()
+		if have, want := err, (any)(nil); have == want {
+			t.Errorf("expected recover to recover from panic:\nhave:\n\t\"%v\"\ndo not want:\n\t\"%v\"", have, want)
+			return
+		}
+
+		cast, castOk := err.(light_client.ErrorLightClientUnimplementedMethod)
+
+		if have, want := castOk, true; have != want {
+			t.Errorf("expected cast to be light_client.ErrorLightClientUnimplementedMethod:\nhave:\n\t\"%v\"\nwant:\n\t\"%v\"", have, want)
+			return
+		}
+
+		if have, want := cast.Method, methodName; have != want {
+			t.Errorf("expected method name to match:\nhave:\n\t\"%v\"\nwant:\n\t\"%v\"", have, want)
+			return
+		}
+	}()
+
+	fn()
+}
+
+// TestUnimplementedExecutionClient tests the UnimplementedLightClientReader
+// to ensure that it panics when any of its methods are called.
+func TestUnimplementedExecutionClient(t *testing.T) {
+	var client light_client.UnimplementedLightClientReader
+
+	t.Run("FetchMerkleRoot", func(t *testing.T) {
+		expectPanicWithErrorLightClientUnimplementedMethod(t, func() {
+			_, _ = client.FetchMerkleRoot(0, nil)
+		}, "FetchMerkleRoot")
+	})
+
+	t.Run("IsHotShotLive", func(t *testing.T) {
+		expectPanicWithErrorLightClientUnimplementedMethod(t, func() {
+			_, _ = client.IsHotShotLive(0)
+		}, "IsHotShotLive")
+	})
+
+	t.Run("IsHotShotLiveAtHeight", func(t *testing.T) {
+		expectPanicWithErrorLightClientUnimplementedMethod(t, func() {
+			_, _ = client.IsHotShotLiveAtHeight(0, 0)
+		}, "IsHotShotLiveAtHeight")
+	})
+
+	t.Run("ValidatedHeight", func(t *testing.T) {
+		expectPanicWithErrorLightClientUnimplementedMethod(t, func() {
+			_, _, _ = client.ValidatedHeight()
+		}, "ValidatedHeight")
+	})
+}
+
+// ExampleErrorLightClientUnimplementedMethod demonstrates how to use the
+// ErrorLightClientUnimplementedMethod error type.
+func ExampleErrorLightClientUnimplementedMethod() {
+	err := light_client.ErrorLightClientUnimplementedMethod{
+		Method: "Hello",
+	}
+
+	fmt.Printf("Error: %s\n", err.Error())
+	// Output: Error: unimplemented light-client method: Hello
+}
diff --git a/system_tests/espresso/transaction_streamer/doc.go b/system_tests/espresso/transaction_streamer/doc.go
new file mode 100644
index 00000000000..099cf5fd8dc
--- /dev/null
+++ b/system_tests/espresso/transaction_streamer/doc.go
@@ -0,0 +1,4 @@
+// Package transaction_streamer provides utilities for testing purposes. It
+// enables a user to quickly spin up a minimal testing environment in order to
+// test the TransactionStreamer and Espresso Chain interactions.
+package transaction_streamer
diff --git a/system_tests/espresso/transaction_streamer/mock_transaction_streamer_environment.go b/system_tests/espresso/transaction_streamer/mock_transaction_streamer_environment.go
new file mode 100644
index 00000000000..c4799ecae07
--- /dev/null
+++ b/system_tests/espresso/transaction_streamer/mock_transaction_streamer_environment.go
@@ -0,0 +1,268 @@
+package transaction_streamer
+
+import (
+	"context"
+	"fmt"
+
+	espresso_client "github.com/EspressoSystems/espresso-network/sdks/go/client"
+
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/params"
+
+	"github.com/offchainlabs/nitro/arbnode"
+	"github.com/offchainlabs/nitro/broadcaster"
+	"github.com/offchainlabs/nitro/espresso/submitter"
+	"github.com/offchainlabs/nitro/execution"
+	chain "github.com/offchainlabs/nitro/system_tests/espresso/chain"
+	execution_engine "github.com/offchainlabs/nitro/system_tests/espresso/execution_engine"
+	"github.com/offchainlabs/nitro/system_tests/espresso/key_manager"
+	"github.com/offchainlabs/nitro/system_tests/espresso/light_client"
+)
+
+// MockTransactionStreamerEnvironmentConfig is a configuration struct for
+// creating a mock Transaction Streamer environment for testing purposes.
+//
+// It allows for custom configuration and setup of the testing environment
+// with different configurable options.
+type MockTransactionStreamerEnvironmentConfig struct {
+	// Transaction Streamer Environment Configuration options
+	Database                         ethdb.Database
+	ChainConfig                      *params.ChainConfig
+	Exec                             execution.ExecutionClient
+	BroadcastServer                  *broadcaster.Broadcaster
+	FatalErrChan                     chan<- error
+	TransactionStreamerConfigFetcher arbnode.TransactionStreamerConfigFetcher
+	SnapSyncConfig                   *arbnode.SnapSyncConfig
+
+	ChainOptions []chain.MockEspressoChainOption
+
+	// Espresso Environment Configuration options
+	EspressoClientOptions []TransactionStreamerEspressoClientOption
+
+	// Espresso Transaction Streamer Configuration
+	EspressoTransactionStreamerOptions []arbnode.TransactionStreamerEspressoOption
+}
+
+// MockTransactionStreamerEnvironmentConfigDefault represents an option that
+// allows for the modification of the MockTransactionStreamerEnvironmentConfig.
+//
+// This allows the caller to modify the configuration of the mock for specific
+// testing scenarios.
+type MockTransactionStreamerEnvironmentOption func(*MockTransactionStreamerEnvironmentConfig)
+
+// TransactionStreamerEspressoClient is a function that modifies the
+// TransactionStreamerEspressoClient in the
+// MockTransactionStreamerEnvironmentConfig.
+//
+// This allows for the modification of the Espresso Client that is used in the
+// TransactionStreamer environment.
+//
+// This is primarily utilized to add layers of functionality to the
+// TransactionStreamerEspressoClient.
+type TransactionStreamerEspressoClientOption func(input espresso_client.EspressoClient) espresso_client.EspressoClient
+
+// ErrorFailedToCreateTransactionStreamer is an error type that indicates that
+// the TransactionStreamer could not be created successfully.
+type ErrorFailedToCreateTransactionStreamer struct {
+	Cause error
+}
+
+// Error implements error
+func (e ErrorFailedToCreateTransactionStreamer) Error() string {
+	return fmt.Sprintf("failed to create TransactionStreamer: %v", e.Cause)
+}
+
+// ErrorFailedToCreateEspressoSubmitter is an error type that indicates that
+// the EspressoSubmitter could not be created successfully.
+type ErrorFailedToCreateEspressoSubmitter struct {
+	Cause error
+}
+
+// Error implements error
+func (e ErrorFailedToCreateEspressoSubmitter) Error() string {
+	return fmt.Sprintf("failed to create EspressoSubmitter: %v", e.Cause)
+}
+
+// WithADatabase is a function that sets the Database in the
+// MockTransactionStreamerEnvironmentConfig.
+func WithDatabase(database ethdb.Database) MockTransactionStreamerEnvironmentOption {
+	return func(config *MockTransactionStreamerEnvironmentConfig) {
+		config.Database = database
+	}
+}
+
+// WithChainConfig is a function that sets the ChainConfig in the
+// MockTransactionStreamerEnvironmentConfig.
+func WithChainConfig(chainConfig *params.ChainConfig) MockTransactionStreamerEnvironmentOption {
+	return func(config *MockTransactionStreamerEnvironmentConfig) {
+		config.ChainConfig = chainConfig
+	}
+}
+
+// WithExecutionSequencer is a function that sets the ExecutionSequencer in the
+// MockTransactionStreamerEnvironmentConfig.
+func WithExecutionSequencer(exec execution.ExecutionClient) MockTransactionStreamerEnvironmentOption {
+	return func(config *MockTransactionStreamerEnvironmentConfig) {
+		config.Exec = exec
+	}
+}
+
+// WithBroadcastServer is a function that sets the BroadcastServer in the
+// MockTransactionStreamerEnvironmentConfig.
+func WithBroadcastServer(broadcastServer *broadcaster.Broadcaster) MockTransactionStreamerEnvironmentOption {
+	return func(config *MockTransactionStreamerEnvironmentConfig) {
+		config.BroadcastServer = broadcastServer
+	}
+}
+
+// WithFatalErrChan is a function that sets the FatalErrChan in the
+// MockTransactionStreamerEnvironmentConfig.
+func WithFatalErrChan(fatalErrChan chan<- error) MockTransactionStreamerEnvironmentOption {
+	return func(config *MockTransactionStreamerEnvironmentConfig) {
+		config.FatalErrChan = fatalErrChan
+	}
+}
+
+// WithTransactionStreamerConfigFetcher is a function that sets the
+// TransactionStreamerConfigFetcher in the
+// MockTransactionStreamerEnvironmentConfig.
+func WithTransactionStreamerConfigFetcher(fetcher arbnode.TransactionStreamerConfigFetcher) MockTransactionStreamerEnvironmentOption {
+	return func(config *MockTransactionStreamerEnvironmentConfig) {
+		config.TransactionStreamerConfigFetcher = fetcher
+	}
+}
+
+// WithSnapSyncConfig is a function that sets the SnapSyncConfig in the
+// MockTransactionStreamerEnvironmentConfig.
+func WithSnapSyncConfig(snapSyncConfig *arbnode.SnapSyncConfig) MockTransactionStreamerEnvironmentOption {
+	return func(config *MockTransactionStreamerEnvironmentConfig) {
+		config.SnapSyncConfig = snapSyncConfig
+	}
+}
+
+// AddChainOptions is a function that adds options to the
+// MockTransactionStreamerEnvironmentConfig for the Mock Espresso Chain.
+func AddChainOptions(options ...chain.MockEspressoChainOption) MockTransactionStreamerEnvironmentOption {
+	return func(config *MockTransactionStreamerEnvironmentConfig) {
+		config.ChainOptions = append(config.ChainOptions, options...)
+	}
+}
+
+// AddEspressoClientOptions is a function that adds options to the Espresso
+// Client in the MockTransactionStreamerEnvironmentConfig.
+func AddEspressoClientOptions(options ...TransactionStreamerEspressoClientOption) MockTransactionStreamerEnvironmentOption {
+	return func(config *MockTransactionStreamerEnvironmentConfig) {
+		config.EspressoClientOptions = append(config.EspressoClientOptions, options...)
+	}
+}
+
+// WithEspressoTransactionStreamerOptions is a function that adds options to the
+// Espresso Transaction Streamer in the MockTransactionStreamerEnvironmentConfig.
+func WithEspressoTransactionStreamerOptions(options ...arbnode.TransactionStreamerEspressoOption) MockTransactionStreamerEnvironmentOption {
+	return func(config *MockTransactionStreamerEnvironmentConfig) {
+		config.EspressoTransactionStreamerOptions = append(config.EspressoTransactionStreamerOptions, options...)
+	}
+}
+
+// WithMultipleMockTransactionStreamerEnvironmentOptions is a function that
+// allows for the application of multiple MockTransactionStreamerEnvironmentOptions
+// to the MockTransactionStreamerEnvironmentConfig.
+func WithMultipleMockTransactionStreamerEnvironmentOptions(options ...MockTransactionStreamerEnvironmentOption) MockTransactionStreamerEnvironmentOption {
+	return func(config *MockTransactionStreamerEnvironmentConfig) {
+		applyMockTransactionStreamerEnvironmentOptions(config, options...)
+	}
+}
+
+// applyMockTransactionStreamerEnvironmentOptions is a helper function that
+// applies the provided MockTransactionStreamerEnvironmentOptions to the
+// MockTransactionStreamerEnvironmentConfig.
+func applyMockTransactionStreamerEnvironmentOptions(config *MockTransactionStreamerEnvironmentConfig, options ...MockTransactionStreamerEnvironmentOption) {
+	for _, option := range options {
+		option(config)
+	}
+}
+
+// NewMockTransactionStreamerEnvironment creates a mock Transaction Streamer
+// environment for testing purposes.
+//
+// The function operates in such a way that it allows for the passed options
+// to modify the configuration of the mock environment (as needed), yet
+// should still provides a default configuration that is suitable for
+// most testing scenarios.
+//
+// Such a setup / approach allows for the consumer of the mock to only
+// modify what is necessary for their specific test case.
+//
+// NOTE: This does not start the TransactionStreamer, start submitting messages
+// to the TransactionStreamer, or start producing blocks in the mock Espresso
+// Chain. Those actions are left to the caller of this function, so they are
+// able to control the timing, and configuration of those actions.
+func NewMockTransactionStreamerEnvironment(ctx context.Context, options ...MockTransactionStreamerEnvironmentOption) (*chain.MockEspressoChain, espresso_client.EspressoClient, submitter.EspressoSubmitter, *arbnode.TransactionStreamer, error) {
+	// Setup the Default Configuration for the Mock Transaction Streamer Environment
+	config := &MockTransactionStreamerEnvironmentConfig{
+		Database:     rawdb.NewMemoryDatabase(),
+		ChainConfig:  params.TestChainConfig,
+		Exec:         execution_engine.NewMockExecutionEngineForTransactionStreamer(),
+		FatalErrChan: make(chan error),
+		TransactionStreamerConfigFetcher: func() *arbnode.TransactionStreamerConfig {
+			return &arbnode.DefaultTransactionStreamerConfig
+		},
+	}
+
+	// Apply the provided options to the configuration
+	applyMockTransactionStreamerEnvironmentOptions(config, options...)
+
+	// Create a mock Espresso Chain
+	espressoChain := chain.NewMockEspressoChain(
+		config.ChainOptions...,
+	)
+
+	// Create and configure the Espresso Client
+	var espressoClient espresso_client.EspressoClient = espressoChain
+	for _, option := range config.EspressoClientOptions {
+		espressoClient = option(espressoClient)
+	}
+
+	// Create the initial Streamer configuration
+	streamer, err := arbnode.NewTransactionStreamer(
+		ctx,
+		config.Database,
+		config.ChainConfig,
+		config.Exec,
+		config.BroadcastServer,
+		config.FatalErrChan,
+		config.TransactionStreamerConfigFetcher,
+		config.SnapSyncConfig,
+	)
+
+	if err != nil {
+		return nil, nil, nil, nil, ErrorFailedToCreateTransactionStreamer{Cause: err}
+	}
+
+	// Configure the Transaction Streamer with the Espresso Fields and options
+	submitter, err := arbnode.ConfigureEspressoFields(
+		streamer,
+		// We setup the initial values before the other options are applied,
+		// so that the other options can modify them as needed.
+		arbnode.WithEspressoClient(espressoClient),
+		arbnode.WithLightClientReader(light_client.NewMockAlwaysLiveLightClientReader()),
+		arbnode.WithKeyManager(key_manager.NewMockEspressoKeyManager()),
+		arbnode.AddSubmitterConfigurationOptions(
+			submitter.WithCanSubmit(func(ctx context.Context) (bool, error) {
+				return true, nil
+			}),
+		),
+
+		// Add the passed in options to the Espresso Transaction Streamer
+		arbnode.WithMultipleEspressoOptions(
+			config.EspressoTransactionStreamerOptions...,
+		),
+	)
+
+	if err != nil {
+		return nil, nil, nil, nil, ErrorFailedToCreateEspressoSubmitter{Cause: err}
+	}
+
+	return espressoChain, espressoClient, submitter, streamer, nil
+}
diff --git a/system_tests/espresso_batcher_monitor_test.go b/system_tests/espresso_batcher_monitor_test.go
new file mode 100644
index 00000000000..2745d9352f5
--- /dev/null
+++ b/system_tests/espresso_batcher_monitor_test.go
@@ -0,0 +1,86 @@
+package arbtest
+
+import (
+	"context"
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/offchainlabs/nitro/arbnode"
+	"github.com/offchainlabs/nitro/espresso/authdb"
+	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
+)
+
+func TestEspressoBatcherMonitor(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	builder, cleanup := createL1AndL2Node(ctx, t, true, false)
+	defer cleanup()
+
+	err := waitForL1Node(ctx)
+	Require(t, err)
+
+	seqInboxAddr := builder.addresses.SequencerInbox
+
+	authDB, err := authdb.NewAuthDB(rawdb.NewMemoryDatabase(), nil, true)
+	Require(t, err)
+
+	monitor := arbnode.NewBatcherAddrMonitor(
+		[]common.Address{},
+		&authDB,
+		builder.L2.ConsensusNode.L1Reader,
+		seqInboxAddr,
+		builder.L2.ConsensusNode.DeployInfo.DeployedAt,
+		builder.L2.ConsensusNode.DeployInfo.DeployedAt,
+		100,
+	)
+	err = monitor.Start(ctx)
+	Require(t, err)
+
+	abi, err := bridgegen.SequencerInboxMetaData.GetAbi()
+	Require(t, err)
+	batchPosterAddr := builder.L2Info.GetAddress("Faucet")
+	data, err := abi.Pack("setIsBatchPoster", batchPosterAddr, true)
+	Require(t, err)
+	tx := builder.L1Info.PrepareTxTo("RollupOwner", &seqInboxAddr, 100000, big.NewInt(0), data)
+	err = builder.L1.Client.SendTransaction(ctx, tx)
+	Require(t, err)
+	receipt, err := EnsureTxSucceededWithTimeout(ctx, builder.L1.Client, tx, time.Second*10)
+	Require(t, err)
+	log.Info("tx receipt", "receipt", receipt.BlockNumber)
+
+	AdvanceL1(t, ctx, builder.L1.Client, builder.L1Info, 100)
+	time.Sleep(time.Second * 25)
+
+	l1Height, err := builder.L1.Client.BlockNumber(ctx)
+	Require(t, err)
+	valid, err := monitor.IsValid(ctx, batchPosterAddr, l1Height)
+	Require(t, err)
+	if !valid {
+		t.Fatal("expect valid")
+	}
+
+	newAddr := common.Address{}
+	data2, err := abi.Pack("setIsBatchPoster", newAddr, false)
+	Require(t, err)
+	tx2 := builder.L1Info.PrepareTxTo("RollupOwner", &seqInboxAddr, 100000, big.NewInt(0), data2)
+	err = builder.L1.Client.SendTransaction(ctx, tx2)
+	Require(t, err)
+	_, err = EnsureTxSucceededWithTimeout(ctx, builder.L1.Client, tx2, time.Second*10)
+	Require(t, err)
+	AdvanceL1(t, ctx, builder.L1.Client, builder.L1Info, 100)
+	time.Sleep(time.Second * 5)
+
+	l1Height, err = builder.L1.Client.BlockNumber(ctx)
+	Require(t, err)
+	valid, err = monitor.IsValid(ctx, newAddr, l1Height)
+	Require(t, err)
+	if valid {
+		t.Fatal("expect invalid")
+	}
+}
diff --git a/system_tests/espresso_e2e_test.go b/system_tests/espresso_e2e_test.go
new file mode 100644
index 00000000000..a8b17909714
--- /dev/null
+++ b/system_tests/espresso_e2e_test.go
@@ -0,0 +1,500 @@
+package arbtest
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"net"
+	"net/http"
+	"os/exec"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/rlp"
+
+	"github.com/offchainlabs/nitro/arbnode"
+	"github.com/offchainlabs/nitro/arbutil"
+	"github.com/offchainlabs/nitro/espresso/submitter"
+	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
+	"github.com/offchainlabs/nitro/validator/server_api"
+	"github.com/offchainlabs/nitro/validator/valnode"
+)
+
+var workingDir = "./espresso-e2e"
+
+var hotShotUrl = "http://127.0.0.1:41000"
+
+var (
+	jitValidationPort = 54320
+	arbValidationPort = 54321
+)
+
+// waitForPortRelease waits for a port to be released (max 10 seconds)
+func waitForPortRelease(port int) {
+	maxRetries := 50 // 50 * 200ms = 10 seconds
+	for i := 0; i < maxRetries; i++ {
+		conn, err := net.DialTimeout("tcp", fmt.Sprintf("127.0.0.1:%d", port), 200*time.Millisecond)
+		if err != nil {
+			// Port is free
+			return
+		}
+		conn.Close()
+		time.Sleep(200 * time.Millisecond)
+	}
+	log.Warn("Port may still be in use", "port", port)
+}
+
+func runEspresso() func() {
+	shutdown := func() {
+		p := exec.Command("docker", "compose", "down", "--volumes")
+		p.Dir = workingDir
+		err := p.Run()
+		if err != nil {
+			panic(err)
+		}
+		// Wait for HotShot port to be released
+		waitForPortRelease(41000)
+	}
+
+	shutdown()
+	invocation := []string{"compose", "up", "-d", "--build"}
+	nodes := []string{
+		"espresso-dev-node",
+	}
+	invocation = append(invocation, nodes...)
+	proceeds := exec.Command("docker", invocation...)
+	proceeds.Dir = workingDir
+
+	go func() {
+		if err := proceeds.Run(); err != nil {
+			panic(err)
+		}
+	}()
+	return shutdown
+}
+
+func createValidationNode(ctx context.Context, t *testing.T, jit bool) func() {
+	stackConf := node.DefaultConfig
+	stackConf.HTTPPort = 0
+	stackConf.DataDir = ""
+	stackConf.WSHost = "127.0.0.1"
+	port := jitValidationPort
+	if !jit {
+		port = arbValidationPort
+	}
+	stackConf.WSPort = port
+	stackConf.WSModules = []string{server_api.Namespace}
+	stackConf.P2P.NoDiscovery = true
+	stackConf.P2P.ListenAddr = ""
+	stackConf.DBEngine = "leveldb" // TODO Try pebble again in future once iterator race condition issues are fixed
+
+	valnode.EnsureValidationExposedViaAuthRPC(&stackConf)
+	config := &valnode.TestValidationConfig
+	config.UseJit = jit
+
+	stack, err := node.New(&stackConf)
+	Require(t, err)
+
+	configFetcher := func() *valnode.Config { return config }
+	node, err := valnode.CreateValidationNode(configFetcher, stack, nil)
+	Require(t, err)
+
+	err = stack.Start()
+	Require(t, err)
+
+	err = node.Start(ctx)
+	Require(t, err)
+
+	go func() {
+		<-ctx.Done()
+		node.GetExec().Stop()
+		stack.Close()
+	}()
+
+	return func() {
+		node.GetExec().Stop()
+		stack.Close()
+		// Wait for port to be fully released before next test
+		waitForPortRelease(port)
+	}
+
+}
+
+func waitFor(
+	ctxinput context.Context,
+	condition func() bool,
+) error {
+	return waitForWith(ctxinput, 30*time.Second, time.Second, condition)
+}
+
+func waitForWith(
+	ctxinput context.Context,
+	timeout time.Duration,
+	interval time.Duration,
+	condition func() bool,
+) error {
+	ctx, cancel := context.WithTimeout(ctxinput, timeout)
+	defer cancel()
+
+	for {
+		if condition() {
+			return nil
+		}
+		select {
+		case <-time.After(interval):
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+}
+
+func waitForEspressoNode(ctx context.Context) error {
+	return waitForWith(ctx, 3*time.Minute, 1*time.Second, func() bool {
+		out, err := exec.Command("curl", "http://localhost:41000/v1/availability/block/10", "-L").Output()
+		if err != nil {
+			log.Warn("retry to check the espresso dev node", "err", err)
+			return false
+		}
+		return len(out) > 0
+	})
+}
+
+func waitForL1Node(ctx context.Context) error {
+	err := waitFor(ctx, func() bool {
+		if e := exec.Command(
+			"curl",
+			"-X",
+			"POST",
+			"-H",
+			"Content-Type: application/json",
+			"-d",
+			"{'jsonrpc':'2.0','id':45678,'method':'eth_chainId','params':[]}",
+			"http://localhost:8545",
+		).Run(); e != nil {
+			log.Warn("retry to check the l1 node", "err", e)
+			return false
+		}
+		return true
+	})
+	if err != nil {
+		return err
+	}
+
+	// wait for L1 to be totally ready to better simulate real-world environment
+	// this is necessary right now to avoid some unknown issues in the dev-node
+	// TODO: find a better way
+	time.Sleep(10 * time.Second)
+	return nil
+}
+
+func TestEspressoE2E(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	builder, cleanup := createL1AndL2Node(ctx, t, true, false)
+	defer cleanup()
+
+	err := waitForL1Node(ctx)
+	Require(t, err)
+
+	shutdown := runEspresso()
+	defer shutdown()
+
+	// wait for the builder
+	err = waitForEspressoNode(ctx)
+	Require(t, err)
+
+	l2Node := builder.L2
+	l2Info := builder.L2Info
+
+	// Wait for the initial message
+	expected := arbutil.MessageIndex(1)
+	err = waitFor(ctx, func() bool {
+		msgCnt, err := l2Node.ConsensusNode.TxStreamer.GetMessageCount()
+		if err != nil {
+			panic(err)
+		}
+
+		validatedCnt := l2Node.ConsensusNode.BlockValidator.Validated(t)
+		return msgCnt >= expected && validatedCnt >= expected
+	})
+	Require(t, err)
+
+	// wait for the latest hotshot block
+	err = waitFor(ctx, func() bool {
+		out, err := exec.Command("curl", "http://127.0.0.1:41000/status/block-height", "-L").Output()
+		if err != nil {
+			return false
+		}
+		h := 0
+		err = json.Unmarshal(out, &h)
+		if err != nil {
+			return false
+		}
+		// Wait for the hotshot to generate some blocks to better simulate the real-world environment.
+		// Chosen based on intuition; no empirical data supports this value.
+		return h > 10
+	})
+	Require(t, err)
+
+	// Check if the tx is executed correctly
+	err = checkTransferTxOnL2(t, ctx, l2Node, "User10", l2Info)
+	Require(t, err)
+
+	// Remember the number of messages
+	var msgCnt arbutil.MessageIndex
+	err = waitFor(ctx, func() bool {
+		cnt, err := l2Node.ConsensusNode.TxStreamer.GetMessageCount()
+		Require(t, err)
+		msgCnt = cnt
+		log.Info("waiting for message count", "cnt", msgCnt)
+		return msgCnt >= 2
+	})
+	Require(t, err)
+
+	// Wait for the number of validated messages to catch up
+	err = waitForWith(ctx, 8*time.Minute, 5*time.Second, func() bool {
+		validatedCnt := l2Node.ConsensusNode.BlockValidator.Validated(t)
+		log.Info("waiting for validation", "validatedCnt", validatedCnt, "msgCnt", msgCnt)
+		return validatedCnt >= msgCnt
+	})
+	Require(t, err)
+
+	newAccount2 := "User11"
+	l2Info.GenerateAccount(newAccount2)
+	addr2 := l2Info.GetAddress(newAccount2)
+
+	// Transfer via the delayed inbox
+	delayedTx := l2Info.PrepareTx("Owner", newAccount2, 3e7, transferAmount, nil)
+	builder.L1.SendWaitTestTransactions(t, []*types.Transaction{
+		WrapL2ForDelayed(t, delayedTx, builder.L1Info, "Faucet", 100000),
+	})
+
+	err = waitForWith(ctx, 180*time.Second, 2*time.Second, func() bool {
+		balance2 := l2Node.GetBalance(t, addr2)
+		log.Info("waiting for balance", "account", newAccount2, "addr", addr2, "balance", balance2)
+		return balance2.Cmp(transferAmount) >= 0
+	})
+	Require(t, err)
+
+	// Test that if espresso node is down, the transaction will be resubmitted once it is back online
+	newAccount3 := "User12"
+	l2Info.GenerateAccount(newAccount3)
+	addr3 := l2Info.GetAddress(newAccount3)
+	tx3 := l2Info.PrepareTx("Faucet", newAccount3, 3e7, transferAmount, nil)
+	builder.L1.SendWaitTestTransactions(t, []*types.Transaction{
+		WrapL2ForDelayed(t, tx3, builder.L1Info, "Faucet", 100000),
+	})
+
+	// Wait for 1 second to make sure txn is submitted to Espresso
+	// but shut down before it can be finalized
+	time.Sleep(1 * time.Second)
+
+	log.Info("Pausing espresso node")
+	pauseEspresso := func() {
+		p := exec.Command("docker", "compose", "pause")
+		p.Dir = workingDir
+		err := p.Run()
+		if err != nil {
+			panic(err)
+		}
+	}
+	pauseEspresso()
+
+	log.Info("Waiting for 1 minute before resuming espresso node")
+	time.Sleep(1 * time.Minute)
+
+	log.Info("Resuming espresso node")
+	unpauseEspresso := func() {
+		// resume the dev node
+		p := exec.Command("docker", "compose", "unpause")
+		p.Dir = workingDir
+		err := p.Run()
+		if err != nil {
+			panic(err)
+		}
+	}
+	unpauseEspresso()
+
+	err = waitForEspressoNode(ctx)
+	Require(t, err)
+
+	// Wait for the L2 chain to catch up.
+	err = waitForWith(ctx, 180*time.Second, 2*time.Second, func() bool {
+		balance3 := l2Node.GetBalance(t, addr3)
+		log.Info("waiting for balance in", "account", newAccount3, "addr", addr3, "balance", balance3)
+		return balance3.Cmp(transferAmount) >= 0
+	})
+	Require(t, err)
+
+	// Try submitting the another transaction to make sure the transaction is submitted
+	// after espresso processes the resubmitted transaction
+	tx4 := l2Info.PrepareTx("Faucet", newAccount3, 3e7, transferAmount, nil)
+
+	builder.L1.SendWaitTestTransactions(t, []*types.Transaction{
+		WrapL2ForDelayed(t, tx4, builder.L1Info, "Faucet", 100000),
+	})
+
+	err = waitForWith(ctx, 180*time.Second, 2*time.Second, func() bool {
+		balance4 := l2Node.GetBalance(t, addr3)
+		log.Info("waiting for balance", "account", newAccount3, "addr", addr3, "balance", balance4)
+		return balance4.Cmp((&big.Int{}).Add(transferAmount, transferAmount)) >= 0
+	})
+	Require(t, err)
+
+	// Now send the transaction for message pos 0, the message position 0 should have not been sent to espresso
+	// because its a genesis message which originates on L1
+	fetcher := func(pos arbutil.MessageIndex) ([]byte, error) {
+		msg, err := l2Node.ConsensusNode.TxStreamer.GetMessage(0)
+		Require(t, err)
+		b, err := rlp.EncodeToBytes(msg)
+		Require(t, err)
+		return b, err
+	}
+
+	payload, _ := arbutil.BuildRawHotShotPayload([]arbutil.MessageIndex{0}, fetcher, 900*1024)
+	payload, err = arbutil.SignHotShotPayload(payload, func([]byte) ([]byte, error) {
+		return []byte{}, nil
+	})
+	Require(t, err)
+
+	// Submit the transaction to hotshot
+	espressoSubmitter := arbnode.GetEspressoSubmitter(l2Node.ConsensusNode.TxStreamer)
+	pollingEspressoSubmitter, castOk := espressoSubmitter.(*submitter.PollingEspressoSubmitter)
+
+	if !castOk {
+		t.Fatal("Expected espresso submitter to be of type PollingEspressoSubmitter")
+	}
+
+	txhash, err := pollingEspressoSubmitter.ResubmitEspressoTransactions(ctx, arbutil.SubmittedEspressoTx{Hash: "", Pos: []arbutil.MessageIndex{0}, Payload: payload})
+	Require(t, err)
+	// Check if the txHash is already finalized in hotshot
+	// curl hotshot availability endpoint and this transaction should not be in the response
+	resp, err := http.Get(fmt.Sprintf("http://127.0.0.1:41000/availability/transaction/hash/%s", txhash))
+	Require(t, err)
+	if resp.StatusCode == 200 {
+		t.Fatal("Transaction should not be in the response")
+	}
+}
+
+func TestEspressoWithBlobs(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// Create L1 and L2 nodes with blobs enabled
+	builder, cleanup := createL1AndL2Node(ctx, t, true, true)
+	defer cleanup()
+
+	err := waitForL1Node(ctx)
+	Require(t, err)
+
+	shutdown := runEspresso()
+	defer shutdown()
+
+	// wait for the builder
+	err = waitForEspressoNode(ctx)
+	Require(t, err)
+
+	l2Node := builder.L2
+	l2Info := builder.L2Info
+
+	// Wait for the initial message
+	expected := arbutil.MessageIndex(1)
+	err = waitFor(ctx, func() bool {
+		msgCnt, err := l2Node.ConsensusNode.TxStreamer.GetMessageCount()
+		if err != nil {
+			panic(err)
+		}
+		return msgCnt >= expected
+	})
+	Require(t, err)
+
+	// wait for the latest hotshot block
+	err = waitFor(ctx, func() bool {
+		out, err := exec.Command("curl", "http://127.0.0.1:41000/status/block-height", "-L").Output()
+		if err != nil {
+			return false
+		}
+		h := 0
+		err = json.Unmarshal(out, &h)
+		if err != nil {
+			return false
+		}
+		// Wait for the hotshot to generate some blocks to better simulate the real-world environment.
+		// Chosen based on intuition; no empirical data supports this value.
+		return h > 10
+	})
+	Require(t, err)
+
+	// Check if the tx is executed correctly
+	err = checkTransferTxOnL2(t, ctx, l2Node, "User10", l2Info)
+	Require(t, err)
+	AdvanceL1(t, ctx, builder.L1.Client, builder.L1Info, 100)
+
+	// Remember the number of messages
+	var msgCnt arbutil.MessageIndex
+	err = waitFor(ctx, func() bool {
+		cnt, err := l2Node.ConsensusNode.TxStreamer.GetMessageCount()
+		Require(t, err)
+		msgCnt = cnt
+		log.Info("waiting for message count", "cnt", msgCnt)
+		return msgCnt >= 2
+	})
+	Require(t, err)
+
+	// Check that the batch sent is greater than 1
+	err = waitForWith(ctx, 8*time.Minute, 5*time.Second, func() bool {
+		// Check the sequencer inbox contract
+
+		sequencerInbox, err := bridgegen.NewSequencerInbox(builder.L1Info.GetAddress("SequencerInbox"), builder.L1.Client)
+		Require(t, err)
+
+		batchCount, err := sequencerInbox.BatchCount(&bind.CallOpts{Context: ctx})
+		Require(t, err)
+		return batchCount.Uint64() > 1
+	})
+	Require(t, err)
+}
+
+func checkTransferTxOnL2(
+	t *testing.T,
+	ctx context.Context,
+	l2Node *TestClient,
+	account string,
+	l2Info *BlockchainTestInfo,
+) error {
+	l2Info.GenerateAccount(account)
+	transferAmount := big.NewInt(1e16)
+	tx := l2Info.PrepareTx("Faucet", account, 3e7, transferAmount, nil)
+
+	err := l2Node.Client.SendTransaction(ctx, tx)
+	if err != nil {
+		return err
+	}
+
+	addr := l2Info.GetAddress(account)
+
+	return waitForWith(ctx, time.Second*300, time.Second*1, func() bool {
+		balance := l2Node.GetBalance(t, addr)
+		log.Info("waiting for balance", "account", account, "addr", addr, "balance", balance)
+		if balance.Cmp(transferAmount) >= 0 {
+			log.Info("target balance reached", "account", account, "addr", addr, "balance", balance)
+			return true
+		}
+		return false
+	})
+}
+
+// system_tests/espresso_e2e_test.go:24:2: "github.com/offchainlabs/nitro/espresso/submitter" imported and not used (typecheck)
+//
+//	"github.com/offchainlabs/nitro/espresso/submitter"
+//	^
+func UnusedSubmitter() submitter.EspressoSubmitter {
+	var a submitter.EspressoSubmitter
+	return a
+}
diff --git a/system_tests/espresso_setup_test.go b/system_tests/espresso_setup_test.go
new file mode 100644
index 00000000000..6f3672c11bd
--- /dev/null
+++ b/system_tests/espresso_setup_test.go
@@ -0,0 +1,96 @@
+package arbtest
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func createL1AndL2Node(
+	ctx context.Context,
+	t *testing.T,
+	delayedSequencer bool,
+	blobsEnabled bool,
+) (*NodeBuilder, func()) {
+	builder := NewNodeBuilder(ctx).DefaultConfig(t, true)
+	builder.l1StackConfig.HTTPPort = 8545
+	builder.l1StackConfig.WSPort = 8546
+	builder.l1StackConfig.HTTPHost = "0.0.0.0"
+	builder.l1StackConfig.HTTPVirtualHosts = []string{"*"}
+	builder.l1StackConfig.WSHost = "0.0.0.0"
+	builder.l1StackConfig.DataDir = t.TempDir()
+	builder.l1StackConfig.WSModules = append(builder.l1StackConfig.WSModules, "eth")
+	builder.l2StackConfig.HTTPPort = 8945
+	builder.l2StackConfig.HTTPHost = "0.0.0.0"
+	builder.l2StackConfig.IPCPath = tmpPath(t, "test.ipc")
+	builder.useL1StackConfig = true
+
+	// poster config
+	builder.nodeConfig.BatchPoster.Enable = true
+	builder.nodeConfig.Espresso.Streamer.TxnsPollingInterval = 2 * time.Second
+	builder.nodeConfig.BatchPoster.ErrorDelay = 5 * time.Second
+	builder.nodeConfig.BatchPoster.MaxSize = 1000
+	builder.nodeConfig.BatchPoster.PollInterval = 10 * time.Second
+	builder.nodeConfig.BatchPoster.MaxDelay = -1000 * time.Hour
+	builder.nodeConfig.Espresso.BatchPoster.HotShotUrl = hotShotUrl
+	builder.nodeConfig.Espresso.BatchPoster.TeeType = "TESTS"
+	builder.DontParalellise()
+
+	// validator config
+	builder.nodeConfig.BlockValidator.Enable = true
+	builder.nodeConfig.BlockValidator.ValidationPoll = 2 * time.Second
+	builder.nodeConfig.BlockValidator.ValidationServer.URL = fmt.Sprintf("ws://127.0.0.1:%d", arbValidationPort)
+	builder.nodeConfig.DelayedSequencer.Enable = delayedSequencer
+	builder.nodeConfig.DelayedSequencer.FinalizeDistance = 1
+
+	// sequencer config
+	builder.nodeConfig.Sequencer = true
+	builder.nodeConfig.ParentChainReader.Enable = true // This flag is necessary to enable sequencing transactions with espresso behavior
+	builder.nodeConfig.ParentChainReader.UseFinalityData = true
+	builder.nodeConfig.Dangerous.NoSequencerCoordinator = true
+	builder.execConfig.Sequencer.Enable = true
+	builder.execConfig.Caching.StateScheme = "hash"
+	builder.execConfig.Caching.Archive = true
+
+	if blobsEnabled {
+		builder.nodeConfig.BatchPoster.Post4844Blobs = true
+		builder.nodeConfig.BatchPoster.IgnoreBlobPrice = true
+		builder.withL1 = true
+		builder.deployBold = false
+		// Enabling this to false because we dont have a blob reader in the tests
+		// which is needed for staker
+		builder.nodeConfig.BlockValidator.Enable = false
+		builder.nodeConfig.Staker.Enable = false
+
+	}
+
+	c := builder.Build(t)
+
+	mnemonic := "indoor dish desk flag debris potato excuse depart ticket judge file exit"
+	err := builder.L1Info.GenerateAccountWithMnemonic("CommitmentTask", mnemonic, 5)
+	Require(t, err)
+	builder.L1.TransferBalance(t, "Faucet", "CommitmentTask", new(big.Int).Mul(big.NewInt(9e18), big.NewInt(1000)), builder.L1Info)
+	cleanup := func() {
+		c()
+		waitForPortRelease(8545)
+		waitForPortRelease(8546)
+		waitForPortRelease(8945)
+		waitForPortRelease(arbValidationPort)
+	}
+
+	return builder, cleanup
+}
+
+func TestCreateEspressoCaffNode(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	valNodeCleanup := createValidationNode(ctx, t, true)
+	defer valNodeCleanup()
+	builder, cleanup := createL1AndL2Node(ctx, t, true, false)
+	defer cleanup()
+	require.Greater(t, builder.nodeConfig.Espresso.BatchPoster.TxnsMonitoringInterval, 0*time.Second, "TxnsMonitoringInterval should be greater than 0")
+}
diff --git a/system_tests/espresso_utils.go b/system_tests/espresso_utils.go
new file mode 100644
index 00000000000..18a7f83d7f6
--- /dev/null
+++ b/system_tests/espresso_utils.go
@@ -0,0 +1,100 @@
+package arbtest
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"fmt"
+	"sync/atomic"
+	"testing"
+
+	hdwallet "github.com/miguelmota/go-ethereum-hdwallet"
+
+	"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/crypto"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/offchainlabs/nitro/arbnode"
+	"github.com/offchainlabs/nitro/espresso-tee-contracts/espressogen"
+	testutils "github.com/offchainlabs/nitro/espresso/test-utils"
+	"github.com/offchainlabs/nitro/espressotee"
+)
+
+func (b *BlockchainTestInfo) GenerateAccountWithMnemonic(name string, mnemonic string, idx uint) error {
+	if b.Accounts[name] != nil {
+		b.T.Fatal("account already exists")
+	}
+	wallet, err := hdwallet.NewFromMnemonic(mnemonic)
+	if err != nil {
+		return err
+	}
+	path := hdwallet.MustParseDerivationPath(fmt.Sprintf("m/44'/60'/0'/0/%d", idx))
+	account, err := wallet.Derive(path, false)
+	if err != nil {
+		return err
+	}
+	privateKey, err := wallet.PrivateKey(account)
+	if err != nil {
+		return err
+	}
+
+	b.Accounts[name] = &AccountInfo{
+		Address:    account.Address,
+		PrivateKey: privateKey,
+		Nonce:      atomic.Uint64{},
+	}
+	log.Info("New Key ", "name", name, "Address", b.Accounts[name].Address)
+	return nil
+}
+
+func createDummyEspressoMetadata(t *testing.T) []byte {
+	return testutils.CreateDummyEspressoMetadata(t)
+}
+
+func deployMockTEEContracts(t *testing.T, transactionOpts *bind.TransactOpts, client *ethclient.Client) (common.Address, *types.Transaction, *espressogen.EspressoTEEVerifierMock, error) {
+	ctx := transactionOpts.Context
+	if ctx == nil {
+		ctx = context.Background()
+	}
+
+	// Register the test key
+	privKey := arbnode.TestEspressoPrivateKey
+
+	nitro, nitroTx, nitroMock, err := espressogen.DeployEspressoNitroTEEVerifierMock(transactionOpts, client)
+	if err != nil {
+		return common.Address{}, nil, nil, fmt.Errorf("failed to deploy EspressoNitroTEEVerifierMock: %w", err)
+	}
+	_, err = bind.WaitDeployed(ctx, client, nitroTx)
+	if err != nil {
+		return common.Address{}, nil, nil, fmt.Errorf("failed to confirm EspressoNitroTEEVerifierMock deployment: %w", err)
+	}
+
+	err = registerNitroMockBatchPosterTestKey(transactionOpts, nitroMock, privKey)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+
+	return espressogen.DeployEspressoTEEVerifierMock(transactionOpts, client, nitro)
+}
+
+func registerNitroMockBatchPosterTestKey(
+	transactionOpts *bind.TransactOpts,
+	nitroMock *espressogen.EspressoNitroTEEVerifierMock,
+	privKey *ecdsa.PrivateKey,
+) error {
+	journalBytes, err := encodeNitroMockBatchPosterVerifierJournalPublicKey(crypto.FromECDSAPub(&privKey.PublicKey))
+	if err != nil {
+		return fmt.Errorf("failed to encode Nitro mock VerifierJournal for batch poster: %w", err)
+	}
+	_, err = nitroMock.RegisterService(transactionOpts, journalBytes, []byte{})
+	if err != nil {
+		return fmt.Errorf("failed to register Nitro mock batch poster test key: %w", err)
+	}
+	return nil
+}
+
+func encodeNitroMockBatchPosterVerifierJournalPublicKey(publicKey []byte) ([]byte, error) {
+	return espressotee.EncodeNitroMockVerifierJournalPublicKey(publicKey)
+}
diff --git a/system_tests/full_challenge_impl_test.go b/system_tests/full_challenge_impl_test.go
index 72619042b80..fb9c4defd36 100644
--- a/system_tests/full_challenge_impl_test.go
+++ b/system_tests/full_challenge_impl_test.go
@@ -158,7 +158,7 @@ func makeBatch(t *testing.T, l2Node *arbnode.Node, l2Info *BlockchainTestInfo, b
 
 	seqNum := new(big.Int).Lsh(common.Big1, 256)
 	seqNum.Sub(seqNum, common.Big1)
-	tx, err := seqInbox.AddSequencerL2BatchFromOrigin8f111f3c(sequencer, seqNum, message, big.NewInt(1), common.Address{}, big.NewInt(0), big.NewInt(0))
+	tx, err := seqInbox.AddSequencerL2BatchFromOrigin37501551(sequencer, seqNum, message, big.NewInt(1), common.Address{}, big.NewInt(0), big.NewInt(0), createDummyEspressoMetadata(t))
 	Require(t, err)
 	receipt, err := EnsureTxSucceeded(ctx, backend, tx)
 	Require(t, err)
@@ -204,6 +204,11 @@ func setupSequencerInboxStub(ctx context.Context, t *testing.T, l1Info *Blockcha
 		DelaySeconds:  big.NewInt(10000),
 		FutureSeconds: big.NewInt(10000),
 	}
+	//  Deploy EspressoTEEVerifier Mock
+	espressoTEEVerifierAddr, tx, _, err := deployMockTEEContracts(t, &txOpts, l1Client)
+	Require(t, err)
+	_, err = EnsureTxSucceeded(ctx, l1Client, tx)
+	Require(t, err)
 	seqInboxAddr, tx, seqInbox, err := mocks_legacy_gen.DeploySequencerInboxStub(
 		&txOpts,
 		l1Client,
@@ -213,6 +218,7 @@ func setupSequencerInboxStub(ctx context.Context, t *testing.T, l1Info *Blockcha
 		big.NewInt(117964),
 		reader4844,
 		false,
+		espressoTEEVerifierAddr,
 	)
 	Require(t, err)
 	_, err = EnsureTxSucceeded(ctx, l1Client, tx)
diff --git a/system_tests/hotshot_listener_test.go b/system_tests/hotshot_listener_test.go
new file mode 100644
index 00000000000..afd82e31a73
--- /dev/null
+++ b/system_tests/hotshot_listener_test.go
@@ -0,0 +1,81 @@
+package arbtest
+
+// import (
+// 	"context"
+// 	"testing"
+// 	"time"
+
+// 	"github.com/ethereum/go-ethereum/log"
+
+// 	hotshot_listener "github.com/offchainlabs/nitro/espresso/hotshot-listener"
+// 	"github.com/offchainlabs/nitro/util/testhelpers"
+// )
+
+// const (
+// 	SEQUENCER_API_WEBSOCKERT_URL = "ws://127.0.0.1:41000/v1"
+// )
+
+// func TestEspressoHotshotListener(t *testing.T) {
+
+// 	ctx, cancel := context.WithCancel(context.Background())
+// 	defer cancel()
+
+// 	builder, cleanup := createL1AndL2Node(ctx, t, true, false)
+// 	defer cleanup()
+
+// 	err := waitForL1Node(ctx)
+// 	Require(t, err)
+// 	shutdown := runEspresso()
+// 	defer shutdown()
+
+// 	logHandler := testhelpers.InitTestLog(t, log.LevelInfo)
+// 	_ = logHandler
+
+// 	// Wait for espresso node to be up
+// 	err = waitForEspressoNode(context.Background())
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	log.Info("Starting the hotshot listener")
+
+// 	// Deploy a RollupSequencerManager contract
+// 	rollupSequencerManagerAddress := builder.L1Info.GetAddress("RollupSequencerManager")
+// 	// Get Sequencer Address
+// 	sequencerAddress := builder.L1Info.GetAddress("Sequencer")
+// 	listener, err := hotshot_listener.NewHotshotListener(SEQUENCER_API_WEBSOCKERT_URL, rollupSequencerManagerAddress.Hex(), builder.L1.Client, sequencerAddress.Hex())
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	// Add retries to the listener start function
+// 	err = listener.Start(context.Background())
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	// Note: These are rudimentary tests to check if the initial basic functionality
+// 	// of the listener works. These tests will be modified in the future to include more processing checks
+
+// 	// Check that we were able to find the quorum proposal and DA proposal for a given view and
+// 	// are now processing it
+// 	err = waitForWith(ctx, 1*time.Minute, 5*time.Second, func() bool {
+// 		return logHandler.WasLogged("processing builder commitment and view number")
+// 	})
+// 	Require(t, err)
+
+// 	// Check that node detected that it needs to process the next view
+// 	err = waitForWith(ctx, 1*time.Minute, 5*time.Second, func() bool {
+// 		return logHandler.WasLogged("next view is this node's view")
+// 	})
+// 	Require(t, err)
+
+// 	// Check that decide event log was also processed
+// 	err = waitForWith(ctx, 1*time.Minute, 5*time.Second, func() bool {
+// 		return logHandler.WasLogged("processing leaf chain")
+// 	})
+// 	Require(t, err)
+
+// 	// Stop and wait for the listener to stop
+// 	listener.StopAndWait()
+// }
diff --git a/system_tests/meaningless_reorg_test.go b/system_tests/meaningless_reorg_test.go
index 6f893c34855..2633f1225db 100644
--- a/system_tests/meaningless_reorg_test.go
+++ b/system_tests/meaningless_reorg_test.go
@@ -27,7 +27,7 @@ func TestMeaninglessBatchReorg(t *testing.T) {
 	Require(t, err)
 	seqOpts := builder.L1Info.GetDefaultTransactOpts("Sequencer", ctx)
 
-	tx, err := seqInbox.AddSequencerL2BatchFromOrigin8f111f3c(&seqOpts, big.NewInt(1), nil, big.NewInt(1), common.Address{}, common.Big0, common.Big0)
+	tx, err := seqInbox.AddSequencerL2BatchFromOrigin37501551(&seqOpts, big.NewInt(1), nil, big.NewInt(1), common.Address{}, common.Big0, common.Big0, createDummyEspressoMetadata(t))
 	Require(t, err)
 	batchReceipt, err := builder.L1.EnsureTxSucceeded(tx)
 	Require(t, err)
@@ -71,7 +71,7 @@ func TestMeaninglessBatchReorg(t *testing.T) {
 	// Produce a new l1Block so that the batch ends up in a different l1Block than before
 	builder.L1.TransferBalance(t, "User", "User", common.Big1, builder.L1Info)
 
-	tx, err = seqInbox.AddSequencerL2BatchFromOrigin8f111f3c(&seqOpts, big.NewInt(1), nil, big.NewInt(1), common.Address{}, common.Big0, common.Big0)
+	tx, err = seqInbox.AddSequencerL2BatchFromOrigin37501551(&seqOpts, big.NewInt(1), nil, big.NewInt(1), common.Address{}, common.Big0, common.Big0, createDummyEspressoMetadata(t))
 	Require(t, err)
 	newBatchReceipt, err := builder.L1.EnsureTxSucceeded(tx)
 	Require(t, err)
diff --git a/system_tests/seqinbox_test.go b/system_tests/seqinbox_test.go
index 0fb0e66187c..69077895b01 100644
--- a/system_tests/seqinbox_test.go
+++ b/system_tests/seqinbox_test.go
@@ -45,9 +45,9 @@ type blockTestState struct {
 const seqInboxTestIters = 40
 
 func encodeAddBatch(seqABI *abi.ABI, seqNum *big.Int, message []byte, afterDelayedMsgRead *big.Int, gasRefunder common.Address) ([]byte, error) {
-	method, ok := seqABI.Methods["addSequencerL2BatchFromOrigin0"]
+	method, ok := seqABI.Methods["addSequencerL2BatchFromOrigin"]
 	if !ok {
-		return nil, errors.New("failed to find add addSequencerL2BatchFromOrigin0 method")
+		return nil, errors.New("failed to find add addSequencerL2BatchFromOrigin method")
 	}
 	inputData, err := method.Inputs.Pack(
 		seqNum,
@@ -56,6 +56,7 @@ func encodeAddBatch(seqABI *abi.ABI, seqNum *big.Int, message []byte, afterDelay
 		gasRefunder,
 		new(big.Int).SetUint64(uint64(1)),
 		new(big.Int).SetUint64(uint64(1)),
+		createDummyEspressoMetadata(nil),
 	)
 	if err != nil {
 		return nil, err
@@ -361,9 +362,9 @@ func testSequencerInboxReaderImpl(t *testing.T, validator bool) {
 				t.Errorf("Access list mismatch:\n%s\n", diff)
 			}
 			if i%5 == 0 {
-				tx, err = seqInbox.AddSequencerL2Batch(&seqOpts, big.NewInt(int64(len(blockStates))), batchData, big.NewInt(1), gasRefunderAddr, big.NewInt(0), big.NewInt(0))
+				tx, err = seqInbox.AddSequencerL2Batch99020501(&seqOpts, big.NewInt(int64(len(blockStates))), batchData, big.NewInt(1), gasRefunderAddr, big.NewInt(0), big.NewInt(0), createDummyEspressoMetadata(t))
 			} else {
-				tx, err = seqInbox.AddSequencerL2BatchFromOrigin8f111f3c(&seqOpts, big.NewInt(int64(len(blockStates))), batchData, big.NewInt(1), gasRefunderAddr, common.Big0, common.Big0)
+				tx, err = seqInbox.AddSequencerL2BatchFromOrigin37501551(&seqOpts, big.NewInt(int64(len(blockStates))), batchData, big.NewInt(1), gasRefunderAddr, common.Big0, common.Big0, createDummyEspressoMetadata(t))
 			}
 			Require(t, err)
 			txRes, err := builder.L1.EnsureTxSucceeded(tx)
diff --git a/util/espresso.go b/util/espresso.go
new file mode 100644
index 00000000000..b3e07abfeb6
--- /dev/null
+++ b/util/espresso.go
@@ -0,0 +1,85 @@
+package util
+
+import "runtime"
+
+// GetNumCPUs is a helper function that returns the number of CPUs available
+// to process.  This returns the value of [runtime.NumCPU] if it is greater
+// than 0, otherwise it returns 1.
+//
+// NOTE: this function is provided to prevent the linting error for converting
+// between an int and a uint.
+func GetNumCPUs() uint64 {
+	// We should always have at least one CPU core available, otherwise
+	// how is this code even being run?
+	return ConvertToUint64WithFallback[int, uint64](runtime.NumCPU(), 1)
+}
+
+// RangeInclusive represents a range of two values that is meant to be
+// include both the start and end values when utilized.
+type RangeInclusive[T Integer] struct {
+	Start, End T
+}
+
+// CreateSliceOfIntegerForRangeInclusive creates a slice of integers from the given
+// start to the end inclusive.
+//
+// The resulting slice will contain a sequence of integers starting at
+// `start`, and ending at `endInclusive`, inclusive.
+//
+// Comprehension: [x | x ∈ [start, endInclusive]]
+func CreateSliceOfIntegerForRangeInclusive[T Integer](start, endInclusive T) []T {
+	if start > endInclusive {
+		return nil
+	}
+
+	len := int(endInclusive - start + 1)
+	result := make([]T, 0, len)
+
+	for i := start; i <= endInclusive; i++ {
+		result = append(result, i)
+	}
+
+	return result
+}
+
+// SignedInteger represents any type that is a signed integer, or whose
+// underlying type is a signed integer.
+type SignedInteger interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64
+}
+
+// ConvertToUint64WithFallback is a helper function that converts a signed
+// integer value to a type whose underlying type is an unsigned 64-bit integer,
+// and returns a fallback value if the signed value is negative. If the value
+func ConvertToUint64WithFallback[T SignedInteger, U ~uint64](value T, fallback U) U {
+	if value < 0 {
+		return fallback
+	}
+
+	return U(value)
+}
+
+// UnsignedInteger represents any type that is an unsigned integer, or whose
+// underlying type is an unsigned integer.
+type UnsignedInteger interface {
+	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
+}
+
+// ConvertToInt64WithFallback is a helper function that converts an unsigned
+// integer value to a type whose underlying type is a signed 64-bit integer,
+// and returns a fallback value if the unsigned value is greater than the
+// maximum value for a signed 64-bit integer.
+func ConvertToInt64WithFallback[T UnsignedInteger, U ~int64](value T, fallback U) U {
+	if uint64(value) > 0x7FFF_FFFF_FFFF_FFFF {
+		return fallback
+	}
+
+	return U(value)
+}
+
+// Integer represents any type that is an Integer.  It specifies all types
+// that are either directly Integer primitives, or a type that inherits their
+// functionality via wrapping.
+type Integer interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
+}
diff --git a/version.json b/version.json
new file mode 100644
index 00000000000..7f61f129c14
--- /dev/null
+++ b/version.json
@@ -0,0 +1,4 @@
+{
+  "upstream": "3.9.8",
+  "espresso": "1.1.0"
+}